A complete copy of the open source open-vcdiff code

This is "soon to be released" open source code.  I have a copy
here to avoid racing for release.  Once it is really on our source server,
I'll pull that instead.

tbr=ajenjo,nsylvain

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@1274 0039d316-1c4b-4281-b951-d872f2087c98

122 files changed, 82866 insertions, 0 deletions

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/AUTHORS b/sdch/open_vcdiff/depot/opensource/open-vcdiff/AUTHORS
new file mode 100644
index 0000000..9b1e9b7
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/AUTHORS
@@ -0,0 +1,2 @@
+opensource@google.com

+

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/COPYING b/sdch/open_vcdiff/depot/opensource/open-vcdiff/COPYING
new file mode 100644
index 0000000..e0171e4
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/COPYING
@@ -0,0 +1,202 @@
+

+                                 Apache License

+                           Version 2.0, January 2004

+                        http://www.apache.org/licenses/

+

+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

+

+   1. Definitions.

+

+      "License" shall mean the terms and conditions for use, reproduction,

+      and distribution as defined by Sections 1 through 9 of this document.

+

+      "Licensor" shall mean the copyright owner or entity authorized by

+      the copyright owner that is granting the License.

+

+      "Legal Entity" shall mean the union of the acting entity and all

+      other entities that control, are controlled by, or are under common

+      control with that entity. For the purposes of this definition,

+      "control" means (i) the power, direct or indirect, to cause the

+      direction or management of such entity, whether by contract or

+      otherwise, or (ii) ownership of fifty percent (50%) or more of the

+      outstanding shares, or (iii) beneficial ownership of such entity.

+

+      "You" (or "Your") shall mean an individual or Legal Entity

+      exercising permissions granted by this License.

+

+      "Source" form shall mean the preferred form for making modifications,

+      including but not limited to software source code, documentation

+      source, and configuration files.

+

+      "Object" form shall mean any form resulting from mechanical

+      transformation or translation of a Source form, including but

+      not limited to compiled object code, generated documentation,

+      and conversions to other media types.

+

+      "Work" shall mean the work of authorship, whether in Source or

+      Object form, made available under the License, as indicated by a

+      copyright notice that is included in or attached to the work

+      (an example is provided in the Appendix below).

+

+      "Derivative Works" shall mean any work, whether in Source or Object

+      form, that is based on (or derived from) the Work and for which the

+      editorial revisions, annotations, elaborations, or other modifications

+      represent, as a whole, an original work of authorship. For the purposes

+      of this License, Derivative Works shall not include works that remain

+      separable from, or merely link (or bind by name) to the interfaces of,

+      the Work and Derivative Works thereof.

+

+      "Contribution" shall mean any work of authorship, including

+      the original version of the Work and any modifications or additions

+      to that Work or Derivative Works thereof, that is intentionally

+      submitted to Licensor for inclusion in the Work by the copyright owner

+      or by an individual or Legal Entity authorized to submit on behalf of

+      the copyright owner. For the purposes of this definition, "submitted"

+      means any form of electronic, verbal, or written communication sent

+      to the Licensor or its representatives, including but not limited to

+      communication on electronic mailing lists, source code control systems,

+      and issue tracking systems that are managed by, or on behalf of, the

+      Licensor for the purpose of discussing and improving the Work, but

+      excluding communication that is conspicuously marked or otherwise

+      designated in writing by the copyright owner as "Not a Contribution."

+

+      "Contributor" shall mean Licensor and any individual or Legal Entity

+      on behalf of whom a Contribution has been received by Licensor and

+      subsequently incorporated within the Work.

+

+   2. Grant of Copyright License. Subject to the terms and conditions of

+      this License, each Contributor hereby grants to You a perpetual,

+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable

+      copyright license to reproduce, prepare Derivative Works of,

+      publicly display, publicly perform, sublicense, and distribute the

+      Work and such Derivative Works in Source or Object form.

+

+   3. Grant of Patent License. Subject to the terms and conditions of

+      this License, each Contributor hereby grants to You a perpetual,

+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable

+      (except as stated in this section) patent license to make, have made,

+      use, offer to sell, sell, import, and otherwise transfer the Work,

+      where such license applies only to those patent claims licensable

+      by such Contributor that are necessarily infringed by their

+      Contribution(s) alone or by combination of their Contribution(s)

+      with the Work to which such Contribution(s) was submitted. If You

+      institute patent litigation against any entity (including a

+      cross-claim or counterclaim in a lawsuit) alleging that the Work

+      or a Contribution incorporated within the Work constitutes direct

+      or contributory patent infringement, then any patent licenses

+      granted to You under this License for that Work shall terminate

+      as of the date such litigation is filed.

+

+   4. Redistribution. You may reproduce and distribute copies of the

+      Work or Derivative Works thereof in any medium, with or without

+      modifications, and in Source or Object form, provided that You

+      meet the following conditions:

+

+      (a) You must give any other recipients of the Work or

+          Derivative Works a copy of this License; and

+

+      (b) You must cause any modified files to carry prominent notices

+          stating that You changed the files; and

+

+      (c) You must retain, in the Source form of any Derivative Works

+          that You distribute, all copyright, patent, trademark, and

+          attribution notices from the Source form of the Work,

+          excluding those notices that do not pertain to any part of

+          the Derivative Works; and

+

+      (d) If the Work includes a "NOTICE" text file as part of its

+          distribution, then any Derivative Works that You distribute must

+          include a readable copy of the attribution notices contained

+          within such NOTICE file, excluding those notices that do not

+          pertain to any part of the Derivative Works, in at least one

+          of the following places: within a NOTICE text file distributed

+          as part of the Derivative Works; within the Source form or

+          documentation, if provided along with the Derivative Works; or,

+          within a display generated by the Derivative Works, if and

+          wherever such third-party notices normally appear. The contents

+          of the NOTICE file are for informational purposes only and

+          do not modify the License. You may add Your own attribution

+          notices within Derivative Works that You distribute, alongside

+          or as an addendum to the NOTICE text from the Work, provided

+          that such additional attribution notices cannot be construed

+          as modifying the License.

+

+      You may add Your own copyright statement to Your modifications and

+      may provide additional or different license terms and conditions

+      for use, reproduction, or distribution of Your modifications, or

+      for any such Derivative Works as a whole, provided Your use,

+      reproduction, and distribution of the Work otherwise complies with

+      the conditions stated in this License.

+

+   5. Submission of Contributions. Unless You explicitly state otherwise,

+      any Contribution intentionally submitted for inclusion in the Work

+      by You to the Licensor shall be under the terms and conditions of

+      this License, without any additional terms or conditions.

+      Notwithstanding the above, nothing herein shall supersede or modify

+      the terms of any separate license agreement you may have executed

+      with Licensor regarding such Contributions.

+

+   6. Trademarks. This License does not grant permission to use the trade

+      names, trademarks, service marks, or product names of the Licensor,

+      except as required for reasonable and customary use in describing the

+      origin of the Work and reproducing the content of the NOTICE file.

+

+   7. Disclaimer of Warranty. Unless required by applicable law or

+      agreed to in writing, Licensor provides the Work (and each

+      Contributor provides its Contributions) on an "AS IS" BASIS,

+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or

+      implied, including, without limitation, any warranties or conditions

+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A

+      PARTICULAR PURPOSE. You are solely responsible for determining the

+      appropriateness of using or redistributing the Work and assume any

+      risks associated with Your exercise of permissions under this License.

+

+   8. Limitation of Liability. In no event and under no legal theory,

+      whether in tort (including negligence), contract, or otherwise,

+      unless required by applicable law (such as deliberate and grossly

+      negligent acts) or agreed to in writing, shall any Contributor be

+      liable to You for damages, including any direct, indirect, special,

+      incidental, or consequential damages of any character arising as a

+      result of this License or out of the use or inability to use the

+      Work (including but not limited to damages for loss of goodwill,

+      work stoppage, computer failure or malfunction, or any and all

+      other commercial damages or losses), even if such Contributor

+      has been advised of the possibility of such damages.

+

+   9. Accepting Warranty or Additional Liability. While redistributing

+      the Work or Derivative Works thereof, You may choose to offer,

+      and charge a fee for, acceptance of support, warranty, indemnity,

+      or other liability obligations and/or rights consistent with this

+      License. However, in accepting such obligations, You may act only

+      on Your own behalf and on Your sole responsibility, not on behalf

+      of any other Contributor, and only if You agree to indemnify,

+      defend, and hold each Contributor harmless for any liability

+      incurred by, or claims asserted against, such Contributor by reason

+      of your accepting any such warranty or additional liability.

+

+   END OF TERMS AND CONDITIONS

+

+   APPENDIX: How to apply the Apache License to your work.

+

+      To apply the Apache License to your work, attach the following

+      boilerplate notice, with the fields enclosed by brackets "[]"

+      replaced with your own identifying information. (Don't include

+      the brackets!)  The text should be enclosed in the appropriate

+      comment syntax for the file format. We also recommend that a

+      file or class name and description of purpose be included on the

+      same "printed page" as the copyright notice for easier

+      identification within third-party archives.

+

+   Copyright (c) 2008, Google Inc.

+

+   Licensed under the Apache License, Version 2.0 (the "License");

+   you may not use this file except in compliance with the License.

+   You may obtain a copy of the License at

+

+       http://www.apache.org/licenses/LICENSE-2.0

+

+   Unless required by applicable law or agreed to in writing, software

+   distributed under the License is distributed on an "AS IS" BASIS,

+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+   See the License for the specific language governing permissions and

+   limitations under the License.

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/ChangeLog b/sdch/open_vcdiff/depot/opensource/open-vcdiff/ChangeLog
new file mode 100644
index 0000000..8efdf30
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/ChangeLog
@@ -0,0 +1,6 @@
+Mon, 16 Jun 2008 15:15:51 -0700  Google Inc. <opensource@google.com>

+

+  * open-vcdiff: initial release:

+  The open-vcdiff package provides an encoder and decoder for the VCDIFF format

+  described in RFC 3284 (http://www.ietf.org/rfc/rfc3284.txt).

+

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/INSTALL b/sdch/open_vcdiff/depot/opensource/open-vcdiff/INSTALL
new file mode 100644
index 0000000..86d6e27
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/INSTALL
@@ -0,0 +1,236 @@
+Installation Instructions

+*************************

+

+Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005 Free

+Software Foundation, Inc.

+

+This file is free documentation; the Free Software Foundation gives

+unlimited permission to copy, distribute and modify it.

+

+Basic Installation

+==================

+

+These are generic installation instructions.

+

+   The `configure' shell script attempts to guess correct values for

+various system-dependent variables used during compilation.  It uses

+those values to create a `Makefile' in each directory of the package.

+It may also create one or more `.h' files containing system-dependent

+definitions.  Finally, it creates a shell script `config.status' that

+you can run in the future to recreate the current configuration, and a

+file `config.log' containing compiler output (useful mainly for

+debugging `configure').

+

+   It can also use an optional file (typically called `config.cache'

+and enabled with `--cache-file=config.cache' or simply `-C') that saves

+the results of its tests to speed up reconfiguring.  (Caching is

+disabled by default to prevent problems with accidental use of stale

+cache files.)

+

+   If you need to do unusual things to compile the package, please try

+to figure out how `configure' could check whether to do them, and mail

+diffs or instructions to the address given in the `README' so they can

+be considered for the next release.  If you are using the cache, and at

+some point `config.cache' contains results you don't want to keep, you

+may remove or edit it.

+

+   The file `configure.ac' (or `configure.in') is used to create

+`configure' by a program called `autoconf'.  You only need

+`configure.ac' if you want to change it or regenerate `configure' using

+a newer version of `autoconf'.

+

+The simplest way to compile this package is:

+

+  1. `cd' to the directory containing the package's source code and type

+     `./configure' to configure the package for your system.  If you're

+     using `csh' on an old version of System V, you might need to type

+     `sh ./configure' instead to prevent `csh' from trying to execute

+     `configure' itself.

+

+     Running `configure' takes awhile.  While running, it prints some

+     messages telling which features it is checking for.

+

+  2. Type `make' to compile the package.

+

+  3. Optionally, type `make check' to run any self-tests that come with

+     the package.

+

+  4. Type `make install' to install the programs and any data files and

+     documentation.

+

+  5. You can remove the program binaries and object files from the

+     source code directory by typing `make clean'.  To also remove the

+     files that `configure' created (so you can compile the package for

+     a different kind of computer), type `make distclean'.  There is

+     also a `make maintainer-clean' target, but that is intended mainly

+     for the package's developers.  If you use it, you may have to get

+     all sorts of other programs in order to regenerate files that came

+     with the distribution.

+

+Compilers and Options

+=====================

+

+Some systems require unusual options for compilation or linking that the

+`configure' script does not know about.  Run `./configure --help' for

+details on some of the pertinent environment variables.

+

+   You can give `configure' initial values for configuration parameters

+by setting variables in the command line or in the environment.  Here

+is an example:

+

+     ./configure CC=c89 CFLAGS=-O2 LIBS=-lposix

+

+   *Note Defining Variables::, for more details.

+

+Compiling For Multiple Architectures

+====================================

+

+You can compile the package for more than one kind of computer at the

+same time, by placing the object files for each architecture in their

+own directory.  To do this, you must use a version of `make' that

+supports the `VPATH' variable, such as GNU `make'.  `cd' to the

+directory where you want the object files and executables to go and run

+the `configure' script.  `configure' automatically checks for the

+source code in the directory that `configure' is in and in `..'.

+

+   If you have to use a `make' that does not support the `VPATH'

+variable, you have to compile the package for one architecture at a

+time in the source code directory.  After you have installed the

+package for one architecture, use `make distclean' before reconfiguring

+for another architecture.

+

+Installation Names

+==================

+

+By default, `make install' installs the package's commands under

+`/usr/local/bin', include files under `/usr/local/include', etc.  You

+can specify an installation prefix other than `/usr/local' by giving

+`configure' the option `--prefix=PREFIX'.

+

+   You can specify separate installation prefixes for

+architecture-specific files and architecture-independent files.  If you

+pass the option `--exec-prefix=PREFIX' to `configure', the package uses

+PREFIX as the prefix for installing programs and libraries.

+Documentation and other data files still use the regular prefix.

+

+   In addition, if you use an unusual directory layout you can give

+options like `--bindir=DIR' to specify different values for particular

+kinds of files.  Run `configure --help' for a list of the directories

+you can set and what kinds of files go in them.

+

+   If the package supports it, you can cause programs to be installed

+with an extra prefix or suffix on their names by giving `configure' the

+option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.

+

+Optional Features

+=================

+

+Some packages pay attention to `--enable-FEATURE' options to

+`configure', where FEATURE indicates an optional part of the package.

+They may also pay attention to `--with-PACKAGE' options, where PACKAGE

+is something like `gnu-as' or `x' (for the X Window System).  The

+`README' should mention any `--enable-' and `--with-' options that the

+package recognizes.

+

+   For packages that use the X Window System, `configure' can usually

+find the X include and library files automatically, but if it doesn't,

+you can use the `configure' options `--x-includes=DIR' and

+`--x-libraries=DIR' to specify their locations.

+

+Specifying the System Type

+==========================

+

+There may be some features `configure' cannot figure out automatically,

+but needs to determine by the type of machine the package will run on.

+Usually, assuming the package is built to be run on the _same_

+architectures, `configure' can figure that out, but if it prints a

+message saying it cannot guess the machine type, give it the

+`--build=TYPE' option.  TYPE can either be a short name for the system

+type, such as `sun4', or a canonical name which has the form:

+

+     CPU-COMPANY-SYSTEM

+

+where SYSTEM can have one of these forms:

+

+     OS KERNEL-OS

+

+   See the file `config.sub' for the possible values of each field.  If

+`config.sub' isn't included in this package, then this package doesn't

+need to know the machine type.

+

+   If you are _building_ compiler tools for cross-compiling, you should

+use the option `--target=TYPE' to select the type of system they will

+produce code for.

+

+   If you want to _use_ a cross compiler, that generates code for a

+platform different from the build platform, you should specify the

+"host" platform (i.e., that on which the generated programs will

+eventually be run) with `--host=TYPE'.

+

+Sharing Defaults

+================

+

+If you want to set default values for `configure' scripts to share, you

+can create a site shell script called `config.site' that gives default

+values for variables like `CC', `cache_file', and `prefix'.

+`configure' looks for `PREFIX/share/config.site' if it exists, then

+`PREFIX/etc/config.site' if it exists.  Or, you can set the

+`CONFIG_SITE' environment variable to the location of the site script.

+A warning: not all `configure' scripts look for a site script.

+

+Defining Variables

+==================

+

+Variables not defined in a site shell script can be set in the

+environment passed to `configure'.  However, some packages may run

+configure again during the build, and the customized values of these

+variables may be lost.  In order to avoid this problem, you should set

+them in the `configure' command line, using `VAR=value'.  For example:

+

+     ./configure CC=/usr/local2/bin/gcc

+

+causes the specified `gcc' to be used as the C compiler (unless it is

+overridden in the site shell script).  Here is a another example:

+

+     /bin/bash ./configure CONFIG_SHELL=/bin/bash

+

+Here the `CONFIG_SHELL=/bin/bash' operand causes subsequent

+configuration-related scripts to be executed by `/bin/bash'.

+

+`configure' Invocation

+======================

+

+`configure' recognizes the following options to control how it operates.

+

+`--help'

+`-h'

+     Print a summary of the options to `configure', and exit.

+

+`--version'

+`-V'

+     Print the version of Autoconf used to generate the `configure'

+     script, and exit.

+

+`--cache-file=FILE'

+     Enable the cache: use and save the results of the tests in FILE,

+     traditionally `config.cache'.  FILE defaults to `/dev/null' to

+     disable caching.

+

+`--config-cache'

+`-C'

+     Alias for `--cache-file=config.cache'.

+

+`--quiet'

+`--silent'

+`-q'

+     Do not print messages saying which checks are being made.  To

+     suppress all normal output, redirect it to `/dev/null' (any error

+     messages will still be shown).

+

+`--srcdir=DIR'

+     Look for the package's source code in directory DIR.  Usually

+     `configure' can determine that directory automatically.

+

+`configure' also accepts some other, not widely useful, options.  Run

+`configure --help' for more details.

+

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/Makefile.am b/sdch/open_vcdiff/depot/opensource/open-vcdiff/Makefile.am
new file mode 100644
index 0000000..1cebf21
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/Makefile.am
@@ -0,0 +1,196 @@
+## Process this file with automake to produce Makefile.in

+

+# Make sure that when we re-make ./configure, we get the macros we need

+# ACLOCAL_AMFLAGS = -I m4

+

+# This is so we can #include <google/foo>

+AM_CPPFLAGS = -I$(top_srcdir)/src

+

+# For a non-optimized (debug) build, change "-DNDEBUG" to "-DDEBUG".

+AM_CXXFLAGS = -DNDEBUG

+

+# Enable verbose gcc warnings.  We use the older option name "-W" to be

+# compatible with gcc v3.3 and earlier.  That option should be changed to

+# "-Wextra" when we can be sure that early gcc versions will not be used.

+if GCC

+AM_CXXFLAGS += -Wall -Wwrite-strings -Woverloaded-virtual -W

+endif

+

+AM_LDFLAGS = -no-undefined

+

+googleincludedir = $(includedir)/google

+## The .h files you want to install (that is, .h files that people

+## who install this package can include in their own applications.)

+googleinclude_HEADERS = src/google/vcdecoder.h src/google/vcencoder.h \

+			src/google/output_string.h

+

+docdir = $(prefix)/share/doc/$(PACKAGE)-$(VERSION)

+## This is for HTML and other documentation you want to install.

+## Add your documentation files (in doc/) in addition to these

+## top-level boilerplate files.  Also add a TODO file if you have one.

+dist_doc_DATA = AUTHORS COPYING ChangeLog INSTALL NEWS README THANKS

+

+## The libraries (.so's) you want to install

+lib_LTLIBRARIES =

+

+## Internal libraries that will not be installed

+noinst_LTLIBRARIES =

+

+## Binaries to be built; these are added in the RULES section

+bin_PROGRAMS =

+

+## unittests you want to run when people type 'make check'.

+## Individual tests are added to TESTS in the RULES section.

+## TESTS is for binary unittests, check_SCRIPTS for script-based unittests.

+## TESTS_ENVIRONMENT sets environment variables for when you run unittest,

+## but it only seems to take effect for *binary* unittests (argh!)

+TESTS =

+TESTS_ENVIRONMENT = SRCDIR="$(top_srcdir)"

+check_SCRIPTS =

+# Every time you add a unittest to check_SCRIPTS, add it here too

+noinst_SCRIPTS =

+

+## vvvv RULES TO MAKE THE LIBRARIES, BINARIES, AND UNITTESTS

+

+# google-gflags: Used for command-line client

+#     Please refer to http://code.google.com/p/google-gflags/ for details

+noinst_LTLIBRARIES += libgflags.la

+libgflags_la_SOURCES = src/google/gflags.h \

+		       src/gflags.cc \

+		       src/gflags_reporting.cc

+

+# gtest (Google Test): Used for unit tests only

+#     Please refer to http://code.google.com/p/googletest/ for details

+noinst_LTLIBRARIES += libgtest.la

+libgtest_la_SOURCES = src/gtest/gtest.h \

+		      src/gtest/gtest-death-test.h \

+		      src/gtest/gtest-message.h \

+		      src/gtest/gtest_pred_impl.h \

+		      src/gtest/gtest-spi.h \

+		      src/gtest/gtest_prod.h \

+		      src/gtest/internal/gtest-death-test-internal.h \

+		      src/gtest/internal/gtest-filepath.h \

+		      src/gtest/internal/gtest-internal.h \

+		      src/gtest/internal/gtest-port.h \

+		      src/gtest/internal/gtest-string.h \

+		      src/gtest/src/gtest-internal-inl.h \

+		      src/gtest/gtest.cc \

+		      src/gtest/gtest-death-test.cc \

+		      src/gtest/gtest-filepath.cc \

+		      src/gtest/gtest-port.cc \

+		      src/testing.h

+

+noinst_LTLIBRARIES += libgtest_main.la

+libgtest_main_la_SOURCES = src/gtest/gtest_main.cc

+libgtest_main_la_LIBADD = libgtest.la

+

+# libvcdcom: The open-vcdiff *common* library

+lib_LTLIBRARIES += libvcdcom.la

+libvcdcom_la_SOURCES = src/google/output_string.h \

+		       src/addrcache.h \

+		       src/checksum.h \

+		       src/codetable.h \

+		       src/logging.h \

+		       src/varint_bigendian.h \

+		       src/vcdiff_defs.h \

+		       src/zlib.h \

+		       src/zconf.h \

+		       src/adler32.c \

+		       src/addrcache.cc \

+		       src/codetable.cc \

+		       src/logging.cc \

+		       src/varint_bigendian.cc

+

+# libvcddec: The open-vcdiff *decoder* library

+lib_LTLIBRARIES += libvcddec.la

+libvcddec_la_SOURCES = src/google/vcdecoder.h \

+		       src/decodetable.h \

+		       src/headerparser.h \

+		       src/decodetable.cc \

+		       src/headerparser.cc \

+		       src/vcdecoder.cc

+libvcddec_la_LIBADD = libvcdcom.la

+

+# libvcdenc: The open-vcdiff *encoder* library

+lib_LTLIBRARIES += libvcdenc.la

+libvcdenc_la_SOURCES = src/google/vcencoder.h \

+		       src/blockhash.h \

+		       src/compile_assert.h \

+		       src/encodetable.h \

+		       src/rolling_hash.h \

+		       src/vcdiffengine.h \

+		       src/blockhash.cc \

+		       src/encodetable.cc \

+		       src/vcdiffengine.cc \

+                       src/vcencoder.cc

+libvcdenc_la_LIBADD = libvcdcom.la

+

+bin_PROGRAMS += vcdiff

+vcdiff_SOURCES = src/vcdiff_main.cc

+vcdiff_LDADD = libvcddec.la libvcdenc.la libgflags.la

+

+TESTS += addrcache_test

+addrcache_test_SOURCES = src/addrcache_test.cc

+addrcache_test_LDADD = libvcdcom.la libgtest_main.la

+

+TESTS += blockhash_test

+blockhash_test_SOURCES = src/blockhash_test.cc

+blockhash_test_LDADD = libvcdenc.la libgtest_main.la

+

+TESTS += codetable_test

+codetable_test_SOURCES = src/codetable_test.cc

+codetable_test_LDADD = libvcdcom.la libgtest_main.la

+

+TESTS += decodetable_test

+decodetable_test_SOURCES = src/decodetable_test.cc

+decodetable_test_LDADD = libvcddec.la libgtest_main.la

+

+TESTS += encodetable_test

+encodetable_test_SOURCES = src/encodetable_test.cc

+encodetable_test_LDADD = libvcdenc.la libgtest_main.la

+

+TESTS += headerparser_test

+headerparser_test_SOURCES = src/headerparser_test.cc

+headerparser_test_LDADD = libvcddec.la libgtest_main.la

+

+TESTS += output_string_test

+output_string_test_SOURCES = src/output_string_test.cc

+output_string_test_LDADD = libgtest_main.la

+

+TESTS += rolling_hash_test

+rolling_hash_test_SOURCES = src/rolling_hash_test.cc

+rolling_hash_test_LDADD = libvcdcom.la libgtest_main.la

+

+TESTS += varint_bigendian_test

+varint_bigendian_test_SOURCES = src/varint_bigendian_test.cc

+varint_bigendian_test_LDADD = libvcdcom.la libgtest_main.la

+

+TESTS += vcdecoder_test

+vcdecoder_test_SOURCES = src/vcdecoder_test.cc

+vcdecoder_test_LDADD = libvcddec.la libgtest_main.la

+

+TESTS += vcdiffengine_test

+vcdiffengine_test_SOURCES = src/vcdiffengine_test.cc

+vcdiffengine_test_LDADD = libvcdenc.la libgtest_main.la

+

+TESTS += vcencoder_test

+vcencoder_test_SOURCES = src/vcencoder_test.cc

+vcencoder_test_LDADD = libvcddec.la libvcdenc.la libgtest_main.la

+

+## ^^^^ END OF RULES TO MAKE THE LIBRARIES, BINARIES, AND UNITTESTS

+

+## This should always include $(TESTS), but may also include other

+## binaries that you compile but don't want automatically installed.

+noinst_PROGRAMS = $(TESTS)

+

+rpm: dist-gzip packages/rpm.sh packages/rpm/rpm.spec

+	@cd packages && ./rpm.sh ${PACKAGE} ${VERSION}

+

+deb: dist-gzip packages/deb.sh packages/deb/*

+	@cd packages && ./deb.sh ${PACKAGE} ${VERSION}

+

+libtool: $(LIBTOOL_DEPS)

+	$(SHELL) ./config.status --recheck

+

+EXTRA_DIST = packages/rpm.sh packages/rpm/rpm.spec packages/deb.sh \

+  packages/deb autogen.sh $(SCRIPTS) libtool

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/Makefile.in b/sdch/open_vcdiff/depot/opensource/open-vcdiff/Makefile.in
new file mode 100644
index 0000000..2aaeede
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/Makefile.in
@@ -0,0 +1,1418 @@
+# Makefile.in generated by automake 1.9.6 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005  Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+# Make sure that when we re-make ./configure, we get the macros we need
+# ACLOCAL_AMFLAGS = -I m4
+
+
+
+
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+top_builddir = .
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+INSTALL = @INSTALL@
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+
+# Enable verbose gcc warnings.
+@GCC_TRUE@am__append_1 = -Wall -Wwrite-strings -Woverloaded-virtual
+bin_PROGRAMS = vcdiff$(EXEEXT)
+noinst_PROGRAMS = $(am__EXEEXT_1)
+DIST_COMMON = README $(am__configure_deps) $(dist_doc_DATA) \
+	$(googleinclude_HEADERS) $(srcdir)/Makefile.am \
+	$(srcdir)/Makefile.in $(top_srcdir)/configure \
+	$(top_srcdir)/src/config.h.in AUTHORS COPYING ChangeLog \
+	INSTALL NEWS THANKS compile config.guess config.sub depcomp \
+	install-sh ltmain.sh missing mkinstalldirs
+subdir = .
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_have_attribute.m4 \
+	$(top_srcdir)/m4/acx_pthread.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
+ configure.lineno configure.status.lineno
+mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
+CONFIG_HEADER = $(top_builddir)/src/config.h
+CONFIG_CLEAN_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = `echo $$p | sed -e 's|^.*/||'`;
+am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)" \
+	"$(DESTDIR)$(docdir)" "$(DESTDIR)$(googleincludedir)"
+libLTLIBRARIES_INSTALL = $(INSTALL)
+LTLIBRARIES = $(lib_LTLIBRARIES) $(noinst_LTLIBRARIES)
+libgflags_la_LIBADD =
+am_libgflags_la_OBJECTS = gflags.lo gflags_reporting.lo
+libgflags_la_OBJECTS = $(am_libgflags_la_OBJECTS)
+libgtest_la_LIBADD =
+am_libgtest_la_OBJECTS = gtest.lo gtest-death-test.lo \
+	gtest-filepath.lo gtest-port.lo
+libgtest_la_OBJECTS = $(am_libgtest_la_OBJECTS)
+libgtest_main_la_DEPENDENCIES = libgtest.la
+am_libgtest_main_la_OBJECTS = gtest_main.lo
+libgtest_main_la_OBJECTS = $(am_libgtest_main_la_OBJECTS)
+libvcdcom_la_LIBADD =
+am_libvcdcom_la_OBJECTS = adler32.lo addrcache.lo codetable.lo \
+	logging.lo varint_bigendian.lo
+libvcdcom_la_OBJECTS = $(am_libvcdcom_la_OBJECTS)
+libvcddec_la_DEPENDENCIES = libvcdcom.la
+am_libvcddec_la_OBJECTS = decodetable.lo headerparser.lo vcdecoder.lo
+libvcddec_la_OBJECTS = $(am_libvcddec_la_OBJECTS)
+libvcdenc_la_DEPENDENCIES = libvcdcom.la
+am_libvcdenc_la_OBJECTS = blockhash.lo encodetable.lo vcdiffengine.lo \
+	vcencoder.lo
+libvcdenc_la_OBJECTS = $(am_libvcdenc_la_OBJECTS)
+binPROGRAMS_INSTALL = $(INSTALL_PROGRAM)
+am__EXEEXT_1 = addrcache_test$(EXEEXT) blockhash_test$(EXEEXT) \
+	codetable_test$(EXEEXT) decodetable_test$(EXEEXT) \
+	encodetable_test$(EXEEXT) headerparser_test$(EXEEXT) \
+	output_string_test$(EXEEXT) rolling_hash_test$(EXEEXT) \
+	varint_bigendian_test$(EXEEXT) vcdecoder_test$(EXEEXT) \
+	vcdiffengine_test$(EXEEXT) vcencoder_test$(EXEEXT)
+PROGRAMS = $(bin_PROGRAMS) $(noinst_PROGRAMS)
+am_addrcache_test_OBJECTS = addrcache_test.$(OBJEXT)
+addrcache_test_OBJECTS = $(am_addrcache_test_OBJECTS)
+addrcache_test_DEPENDENCIES = libvcdcom.la libgtest_main.la
+am_blockhash_test_OBJECTS = blockhash_test.$(OBJEXT)
+blockhash_test_OBJECTS = $(am_blockhash_test_OBJECTS)
+blockhash_test_DEPENDENCIES = libvcdenc.la libgtest_main.la
+am_codetable_test_OBJECTS = codetable_test.$(OBJEXT)
+codetable_test_OBJECTS = $(am_codetable_test_OBJECTS)
+codetable_test_DEPENDENCIES = libvcdcom.la libgtest_main.la
+am_decodetable_test_OBJECTS = decodetable_test.$(OBJEXT)
+decodetable_test_OBJECTS = $(am_decodetable_test_OBJECTS)
+decodetable_test_DEPENDENCIES = libvcddec.la libgtest_main.la
+am_encodetable_test_OBJECTS = encodetable_test.$(OBJEXT)
+encodetable_test_OBJECTS = $(am_encodetable_test_OBJECTS)
+encodetable_test_DEPENDENCIES = libvcdenc.la libgtest_main.la
+am_headerparser_test_OBJECTS = headerparser_test.$(OBJEXT)
+headerparser_test_OBJECTS = $(am_headerparser_test_OBJECTS)
+headerparser_test_DEPENDENCIES = libvcddec.la libgtest_main.la
+am_output_string_test_OBJECTS = output_string_test.$(OBJEXT)
+output_string_test_OBJECTS = $(am_output_string_test_OBJECTS)
+output_string_test_DEPENDENCIES = libgtest_main.la
+am_rolling_hash_test_OBJECTS = rolling_hash_test.$(OBJEXT)
+rolling_hash_test_OBJECTS = $(am_rolling_hash_test_OBJECTS)
+rolling_hash_test_DEPENDENCIES = libvcdcom.la libgtest_main.la
+am_varint_bigendian_test_OBJECTS = varint_bigendian_test.$(OBJEXT)
+varint_bigendian_test_OBJECTS = $(am_varint_bigendian_test_OBJECTS)
+varint_bigendian_test_DEPENDENCIES = libvcdcom.la libgtest_main.la
+am_vcdecoder_test_OBJECTS = vcdecoder_test.$(OBJEXT)
+vcdecoder_test_OBJECTS = $(am_vcdecoder_test_OBJECTS)
+vcdecoder_test_DEPENDENCIES = libvcddec.la libgtest_main.la
+am_vcdiff_OBJECTS = vcdiff_main.$(OBJEXT)
+vcdiff_OBJECTS = $(am_vcdiff_OBJECTS)
+vcdiff_DEPENDENCIES = libvcddec.la libvcdenc.la libgflags.la
+am_vcdiffengine_test_OBJECTS = vcdiffengine_test.$(OBJEXT)
+vcdiffengine_test_OBJECTS = $(am_vcdiffengine_test_OBJECTS)
+vcdiffengine_test_DEPENDENCIES = libvcdenc.la libgtest_main.la
+am_vcencoder_test_OBJECTS = vcencoder_test.$(OBJEXT)
+vcencoder_test_OBJECTS = $(am_vcencoder_test_OBJECTS)
+vcencoder_test_DEPENDENCIES = libvcddec.la libvcdenc.la \
+	libgtest_main.la
+SCRIPTS = $(noinst_SCRIPTS)
+DEFAULT_INCLUDES = -I. -I$(srcdir) -I$(top_builddir)/src
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) \
+	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+	$(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --tag=CC --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(AM_LDFLAGS) $(LDFLAGS) -o $@
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) \
+	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+	$(AM_CXXFLAGS) $(CXXFLAGS)
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) --tag=CXX --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+	$(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+SOURCES = $(libgflags_la_SOURCES) $(libgtest_la_SOURCES) \
+	$(libgtest_main_la_SOURCES) $(libvcdcom_la_SOURCES) \
+	$(libvcddec_la_SOURCES) $(libvcdenc_la_SOURCES) \
+	$(addrcache_test_SOURCES) $(blockhash_test_SOURCES) \
+	$(codetable_test_SOURCES) $(decodetable_test_SOURCES) \
+	$(encodetable_test_SOURCES) $(headerparser_test_SOURCES) \
+	$(output_string_test_SOURCES) $(rolling_hash_test_SOURCES) \
+	$(varint_bigendian_test_SOURCES) $(vcdecoder_test_SOURCES) \
+	$(vcdiff_SOURCES) $(vcdiffengine_test_SOURCES) \
+	$(vcencoder_test_SOURCES)
+DIST_SOURCES = $(libgflags_la_SOURCES) $(libgtest_la_SOURCES) \
+	$(libgtest_main_la_SOURCES) $(libvcdcom_la_SOURCES) \
+	$(libvcddec_la_SOURCES) $(libvcdenc_la_SOURCES) \
+	$(addrcache_test_SOURCES) $(blockhash_test_SOURCES) \
+	$(codetable_test_SOURCES) $(decodetable_test_SOURCES) \
+	$(encodetable_test_SOURCES) $(headerparser_test_SOURCES) \
+	$(output_string_test_SOURCES) $(rolling_hash_test_SOURCES) \
+	$(varint_bigendian_test_SOURCES) $(vcdecoder_test_SOURCES) \
+	$(vcdiff_SOURCES) $(vcdiffengine_test_SOURCES) \
+	$(vcencoder_test_SOURCES)
+dist_docDATA_INSTALL = $(INSTALL_DATA)
+DATA = $(dist_doc_DATA)
+googleincludeHEADERS_INSTALL = $(INSTALL_HEADER)
+HEADERS = $(googleinclude_HEADERS)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+distdir = $(PACKAGE)-$(VERSION)
+top_distdir = $(distdir)
+am__remove_distdir = \
+  { test ! -d $(distdir) \
+    || { find $(distdir) -type d ! -perm -200 -exec chmod u+w {} ';' \
+         && rm -fr $(distdir); }; }
+DIST_ARCHIVES = $(distdir).tar.gz
+GZIP_ENV = --best
+distuninstallcheck_listfiles = find . -type f -print
+distcleancheck_listfiles = find . -type f -print
+ACLOCAL = @ACLOCAL@
+AMDEP_FALSE = @AMDEP_FALSE@
+AMDEP_TRUE = @AMDEP_TRUE@
+AMTAR = @AMTAR@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+ECHO = @ECHO@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+F77 = @F77@
+FFLAGS = @FFLAGS@
+GCC_FALSE = @GCC_FALSE@
+GCC_TRUE = @GCC_TRUE@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIBTOOL_DEPS = @LIBTOOL_DEPS@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+OBJEXT = @OBJEXT@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PTHREAD_CC = @PTHREAD_CC@
+PTHREAD_CFLAGS = @PTHREAD_CFLAGS@
+PTHREAD_LIBS = @PTHREAD_LIBS@
+RANLIB = @RANLIB@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_F77 = @ac_ct_F77@
+ac_ct_RANLIB = @ac_ct_RANLIB@
+ac_ct_STRIP = @ac_ct_STRIP@
+acx_pthread_config = @acx_pthread_config@
+am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+am__fastdepCXX_FALSE = @am__fastdepCXX_FALSE@
+am__fastdepCXX_TRUE = @am__fastdepCXX_TRUE@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+datadir = @datadir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+
+# This is so we can #include <google/foo>
+AM_CPPFLAGS = -I$(top_srcdir)/src
+
+# For a non-optimized (debug) build, change "-DNDEBUG" to "-DDEBUG".
+AM_CXXFLAGS = -DNDEBUG $(am__append_1)
+AM_LDFLAGS = -no-undefined
+googleincludedir = $(includedir)/google
+googleinclude_HEADERS = src/google/vcdecoder.h src/google/vcencoder.h \
+			src/google/output_string.h
+
+docdir = $(prefix)/share/doc/$(PACKAGE)-$(VERSION)
+dist_doc_DATA = AUTHORS COPYING ChangeLog INSTALL NEWS README THANKS
+
+# libvcdcom: The open-vcdiff *common* library
+
+# libvcddec: The open-vcdiff *decoder* library
+
+# libvcdenc: The open-vcdiff *encoder* library
+lib_LTLIBRARIES = libvcdcom.la libvcddec.la libvcdenc.la
+
+# google-gflags: Used for command-line client
+#     Please refer to http://code.google.com/p/google-gflags/ for details
+
+# gtest (Google Test): Used for unit tests only
+#     Please refer to http://code.google.com/p/googletest/ for details
+noinst_LTLIBRARIES = libgflags.la libgtest.la libgtest_main.la
+TESTS = addrcache_test blockhash_test codetable_test decodetable_test \
+	encodetable_test headerparser_test output_string_test \
+	rolling_hash_test varint_bigendian_test vcdecoder_test \
+	vcdiffengine_test vcencoder_test
+TESTS_ENVIRONMENT = SRCDIR="$(top_srcdir)"
+check_SCRIPTS = 
+# Every time you add a unittest to check_SCRIPTS, add it here too
+noinst_SCRIPTS = 
+libgflags_la_SOURCES = src/google/gflags.h \
+		       src/gflags.cc \
+		       src/gflags_reporting.cc
+
+libgtest_la_SOURCES = src/gtest/gtest.h \
+		      src/gtest/gtest-death-test.h \
+		      src/gtest/gtest-message.h \
+		      src/gtest/gtest_pred_impl.h \
+		      src/gtest/gtest-spi.h \
+		      src/gtest/gtest_prod.h \
+		      src/gtest/internal/gtest-death-test-internal.h \
+		      src/gtest/internal/gtest-filepath.h \
+		      src/gtest/internal/gtest-internal.h \
+		      src/gtest/internal/gtest-port.h \
+		      src/gtest/internal/gtest-string.h \
+		      src/gtest/src/gtest-internal-inl.h \
+		      src/gtest/gtest.cc \
+		      src/gtest/gtest-death-test.cc \
+		      src/gtest/gtest-filepath.cc \
+		      src/gtest/gtest-port.cc \
+		      src/testing.h
+
+libgtest_main_la_SOURCES = src/gtest/gtest_main.cc
+libgtest_main_la_LIBADD = libgtest.la
+libvcdcom_la_SOURCES = src/google/output_string.h \
+		       src/addrcache.h \
+		       src/checksum.h \
+		       src/codetable.h \
+		       src/logging.h \
+		       src/varint_bigendian.h \
+		       src/vcdiff_defs.h \
+		       src/zlib.h \
+		       src/zconf.h \
+		       src/adler32.c \
+		       src/addrcache.cc \
+		       src/codetable.cc \
+		       src/logging.cc \
+		       src/varint_bigendian.cc
+
+libvcddec_la_SOURCES = src/google/vcdecoder.h \
+		       src/decodetable.h \
+		       src/headerparser.h \
+		       src/decodetable.cc \
+		       src/headerparser.cc \
+		       src/vcdecoder.cc
+
+libvcddec_la_LIBADD = libvcdcom.la
+libvcdenc_la_SOURCES = src/google/vcencoder.h \
+		       src/blockhash.h \
+		       src/compile_assert.h \
+		       src/encodetable.h \
+		       src/rolling_hash.h \
+		       src/vcdiffengine.h \
+		       src/blockhash.cc \
+		       src/encodetable.cc \
+		       src/vcdiffengine.cc \
+                       src/vcencoder.cc
+
+libvcdenc_la_LIBADD = libvcdcom.la
+vcdiff_SOURCES = src/vcdiff_main.cc
+vcdiff_LDADD = libvcddec.la libvcdenc.la libgflags.la
+addrcache_test_SOURCES = src/addrcache_test.cc
+addrcache_test_LDADD = libvcdcom.la libgtest_main.la
+blockhash_test_SOURCES = src/blockhash_test.cc
+blockhash_test_LDADD = libvcdenc.la libgtest_main.la
+codetable_test_SOURCES = src/codetable_test.cc
+codetable_test_LDADD = libvcdcom.la libgtest_main.la
+decodetable_test_SOURCES = src/decodetable_test.cc
+decodetable_test_LDADD = libvcddec.la libgtest_main.la
+encodetable_test_SOURCES = src/encodetable_test.cc
+encodetable_test_LDADD = libvcdenc.la libgtest_main.la
+headerparser_test_SOURCES = src/headerparser_test.cc
+headerparser_test_LDADD = libvcddec.la libgtest_main.la
+output_string_test_SOURCES = src/output_string_test.cc
+output_string_test_LDADD = libgtest_main.la
+rolling_hash_test_SOURCES = src/rolling_hash_test.cc
+rolling_hash_test_LDADD = libvcdcom.la libgtest_main.la
+varint_bigendian_test_SOURCES = src/varint_bigendian_test.cc
+varint_bigendian_test_LDADD = libvcdcom.la libgtest_main.la
+vcdecoder_test_SOURCES = src/vcdecoder_test.cc
+vcdecoder_test_LDADD = libvcddec.la libgtest_main.la
+vcdiffengine_test_SOURCES = src/vcdiffengine_test.cc
+vcdiffengine_test_LDADD = libvcdenc.la libgtest_main.la
+vcencoder_test_SOURCES = src/vcencoder_test.cc
+vcencoder_test_LDADD = libvcddec.la libvcdenc.la libgtest_main.la
+EXTRA_DIST = packages/rpm.sh packages/rpm/rpm.spec packages/deb.sh \
+  packages/deb autogen.sh $(SCRIPTS) libtool
+
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .cc .lo .o .obj
+am--refresh:
+	@:
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      echo ' cd $(srcdir) && $(AUTOMAKE) --gnu '; \
+	      cd $(srcdir) && $(AUTOMAKE) --gnu  \
+		&& exit 0; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu  Makefile'; \
+	cd $(top_srcdir) && \
+	  $(AUTOMAKE) --gnu  Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    echo ' $(SHELL) ./config.status'; \
+	    $(SHELL) ./config.status;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	$(SHELL) ./config.status --recheck
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+	cd $(srcdir) && $(AUTOCONF)
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+	cd $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS)
+
+src/config.h: src/stamp-h1
+	@if test ! -f $@; then \
+	  rm -f src/stamp-h1; \
+	  $(MAKE) src/stamp-h1; \
+	else :; fi
+
+src/stamp-h1: $(top_srcdir)/src/config.h.in $(top_builddir)/config.status
+	@rm -f src/stamp-h1
+	cd $(top_builddir) && $(SHELL) ./config.status src/config.h
+$(top_srcdir)/src/config.h.in:  $(am__configure_deps) 
+	cd $(top_srcdir) && $(AUTOHEADER)
+	rm -f src/stamp-h1
+	touch $@
+
+distclean-hdr:
+	-rm -f src/config.h src/stamp-h1
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+	@$(NORMAL_INSTALL)
+	test -z "$(libdir)" || $(mkdir_p) "$(DESTDIR)$(libdir)"
+	@list='$(lib_LTLIBRARIES)'; for p in $$list; do \
+	  if test -f $$p; then \
+	    f=$(am__strip_dir) \
+	    echo " $(LIBTOOL) --mode=install $(libLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) '$$p' '$(DESTDIR)$(libdir)/$$f'"; \
+	    $(LIBTOOL) --mode=install $(libLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) "$$p" "$(DESTDIR)$(libdir)/$$f"; \
+	  else :; fi; \
+	done
+
+uninstall-libLTLIBRARIES:
+	@$(NORMAL_UNINSTALL)
+	@set -x; list='$(lib_LTLIBRARIES)'; for p in $$list; do \
+	  p=$(am__strip_dir) \
+	  echo " $(LIBTOOL) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$p'"; \
+	  $(LIBTOOL) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$p"; \
+	done
+
+clean-libLTLIBRARIES:
+	-test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+	@list='$(lib_LTLIBRARIES)'; for p in $$list; do \
+	  dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
+	  test "$$dir" != "$$p" || dir=.; \
+	  echo "rm -f \"$${dir}/so_locations\""; \
+	  rm -f "$${dir}/so_locations"; \
+	done
+
+clean-noinstLTLIBRARIES:
+	-test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES)
+	@list='$(noinst_LTLIBRARIES)'; for p in $$list; do \
+	  dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
+	  test "$$dir" != "$$p" || dir=.; \
+	  echo "rm -f \"$${dir}/so_locations\""; \
+	  rm -f "$${dir}/so_locations"; \
+	done
+libgflags.la: $(libgflags_la_OBJECTS) $(libgflags_la_DEPENDENCIES) 
+	$(CXXLINK)  $(libgflags_la_LDFLAGS) $(libgflags_la_OBJECTS) $(libgflags_la_LIBADD) $(LIBS)
+libgtest.la: $(libgtest_la_OBJECTS) $(libgtest_la_DEPENDENCIES) 
+	$(CXXLINK)  $(libgtest_la_LDFLAGS) $(libgtest_la_OBJECTS) $(libgtest_la_LIBADD) $(LIBS)
+libgtest_main.la: $(libgtest_main_la_OBJECTS) $(libgtest_main_la_DEPENDENCIES) 
+	$(CXXLINK)  $(libgtest_main_la_LDFLAGS) $(libgtest_main_la_OBJECTS) $(libgtest_main_la_LIBADD) $(LIBS)
+libvcdcom.la: $(libvcdcom_la_OBJECTS) $(libvcdcom_la_DEPENDENCIES) 
+	$(CXXLINK) -rpath $(libdir) $(libvcdcom_la_LDFLAGS) $(libvcdcom_la_OBJECTS) $(libvcdcom_la_LIBADD) $(LIBS)
+libvcddec.la: $(libvcddec_la_OBJECTS) $(libvcddec_la_DEPENDENCIES) 
+	$(CXXLINK) -rpath $(libdir) $(libvcddec_la_LDFLAGS) $(libvcddec_la_OBJECTS) $(libvcddec_la_LIBADD) $(LIBS)
+libvcdenc.la: $(libvcdenc_la_OBJECTS) $(libvcdenc_la_DEPENDENCIES) 
+	$(CXXLINK) -rpath $(libdir) $(libvcdenc_la_LDFLAGS) $(libvcdenc_la_OBJECTS) $(libvcdenc_la_LIBADD) $(LIBS)
+install-binPROGRAMS: $(bin_PROGRAMS)
+	@$(NORMAL_INSTALL)
+	test -z "$(bindir)" || $(mkdir_p) "$(DESTDIR)$(bindir)"
+	@list='$(bin_PROGRAMS)'; for p in $$list; do \
+	  p1=`echo $$p|sed 's/$(EXEEXT)$$//'`; \
+	  if test -f $$p \
+	     || test -f $$p1 \
+	  ; then \
+	    f=`echo "$$p1" | sed 's,^.*/,,;$(transform);s/$$/$(EXEEXT)/'`; \
+	   echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) --mode=install $(binPROGRAMS_INSTALL) '$$p' '$(DESTDIR)$(bindir)/$$f'"; \
+	   $(INSTALL_PROGRAM_ENV) $(LIBTOOL) --mode=install $(binPROGRAMS_INSTALL) "$$p" "$(DESTDIR)$(bindir)/$$f" || exit 1; \
+	  else :; fi; \
+	done
+
+uninstall-binPROGRAMS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(bin_PROGRAMS)'; for p in $$list; do \
+	  f=`echo "$$p" | sed 's,^.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/'`; \
+	  echo " rm -f '$(DESTDIR)$(bindir)/$$f'"; \
+	  rm -f "$(DESTDIR)$(bindir)/$$f"; \
+	done
+
+clean-binPROGRAMS:
+	@list='$(bin_PROGRAMS)'; for p in $$list; do \
+	  f=`echo $$p|sed 's/$(EXEEXT)$$//'`; \
+	  echo " rm -f $$p $$f"; \
+	  rm -f $$p $$f ; \
+	done
+
+clean-noinstPROGRAMS:
+	@list='$(noinst_PROGRAMS)'; for p in $$list; do \
+	  f=`echo $$p|sed 's/$(EXEEXT)$$//'`; \
+	  echo " rm -f $$p $$f"; \
+	  rm -f $$p $$f ; \
+	done
+addrcache_test$(EXEEXT): $(addrcache_test_OBJECTS) $(addrcache_test_DEPENDENCIES) 
+	@rm -f addrcache_test$(EXEEXT)
+	$(CXXLINK) $(addrcache_test_LDFLAGS) $(addrcache_test_OBJECTS) $(addrcache_test_LDADD) $(LIBS)
+blockhash_test$(EXEEXT): $(blockhash_test_OBJECTS) $(blockhash_test_DEPENDENCIES) 
+	@rm -f blockhash_test$(EXEEXT)
+	$(CXXLINK) $(blockhash_test_LDFLAGS) $(blockhash_test_OBJECTS) $(blockhash_test_LDADD) $(LIBS)
+codetable_test$(EXEEXT): $(codetable_test_OBJECTS) $(codetable_test_DEPENDENCIES) 
+	@rm -f codetable_test$(EXEEXT)
+	$(CXXLINK) $(codetable_test_LDFLAGS) $(codetable_test_OBJECTS) $(codetable_test_LDADD) $(LIBS)
+decodetable_test$(EXEEXT): $(decodetable_test_OBJECTS) $(decodetable_test_DEPENDENCIES) 
+	@rm -f decodetable_test$(EXEEXT)
+	$(CXXLINK) $(decodetable_test_LDFLAGS) $(decodetable_test_OBJECTS) $(decodetable_test_LDADD) $(LIBS)
+encodetable_test$(EXEEXT): $(encodetable_test_OBJECTS) $(encodetable_test_DEPENDENCIES) 
+	@rm -f encodetable_test$(EXEEXT)
+	$(CXXLINK) $(encodetable_test_LDFLAGS) $(encodetable_test_OBJECTS) $(encodetable_test_LDADD) $(LIBS)
+headerparser_test$(EXEEXT): $(headerparser_test_OBJECTS) $(headerparser_test_DEPENDENCIES) 
+	@rm -f headerparser_test$(EXEEXT)
+	$(CXXLINK) $(headerparser_test_LDFLAGS) $(headerparser_test_OBJECTS) $(headerparser_test_LDADD) $(LIBS)
+output_string_test$(EXEEXT): $(output_string_test_OBJECTS) $(output_string_test_DEPENDENCIES) 
+	@rm -f output_string_test$(EXEEXT)
+	$(CXXLINK) $(output_string_test_LDFLAGS) $(output_string_test_OBJECTS) $(output_string_test_LDADD) $(LIBS)
+rolling_hash_test$(EXEEXT): $(rolling_hash_test_OBJECTS) $(rolling_hash_test_DEPENDENCIES) 
+	@rm -f rolling_hash_test$(EXEEXT)
+	$(CXXLINK) $(rolling_hash_test_LDFLAGS) $(rolling_hash_test_OBJECTS) $(rolling_hash_test_LDADD) $(LIBS)
+varint_bigendian_test$(EXEEXT): $(varint_bigendian_test_OBJECTS) $(varint_bigendian_test_DEPENDENCIES) 
+	@rm -f varint_bigendian_test$(EXEEXT)
+	$(CXXLINK) $(varint_bigendian_test_LDFLAGS) $(varint_bigendian_test_OBJECTS) $(varint_bigendian_test_LDADD) $(LIBS)
+vcdecoder_test$(EXEEXT): $(vcdecoder_test_OBJECTS) $(vcdecoder_test_DEPENDENCIES) 
+	@rm -f vcdecoder_test$(EXEEXT)
+	$(CXXLINK) $(vcdecoder_test_LDFLAGS) $(vcdecoder_test_OBJECTS) $(vcdecoder_test_LDADD) $(LIBS)
+vcdiff$(EXEEXT): $(vcdiff_OBJECTS) $(vcdiff_DEPENDENCIES) 
+	@rm -f vcdiff$(EXEEXT)
+	$(CXXLINK) $(vcdiff_LDFLAGS) $(vcdiff_OBJECTS) $(vcdiff_LDADD) $(LIBS)
+vcdiffengine_test$(EXEEXT): $(vcdiffengine_test_OBJECTS) $(vcdiffengine_test_DEPENDENCIES) 
+	@rm -f vcdiffengine_test$(EXEEXT)
+	$(CXXLINK) $(vcdiffengine_test_LDFLAGS) $(vcdiffengine_test_OBJECTS) $(vcdiffengine_test_LDADD) $(LIBS)
+vcencoder_test$(EXEEXT): $(vcencoder_test_OBJECTS) $(vcencoder_test_DEPENDENCIES) 
+	@rm -f vcencoder_test$(EXEEXT)
+	$(CXXLINK) $(vcencoder_test_LDFLAGS) $(vcencoder_test_OBJECTS) $(vcencoder_test_LDADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/addrcache.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/addrcache_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/adler32.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/blockhash.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/blockhash_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/codetable.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/codetable_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/decodetable.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/decodetable_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/encodetable.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/encodetable_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gflags.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gflags_reporting.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gtest-death-test.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gtest-filepath.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gtest-port.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gtest.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gtest_main.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/headerparser.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/headerparser_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/logging.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/output_string_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rolling_hash_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/varint_bigendian.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/varint_bigendian_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vcdecoder.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vcdecoder_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vcdiff_main.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vcdiffengine.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vcdiffengine_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vcencoder.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vcencoder_test.Po@am__quote@
+
+.c.o:
+@am__fastdepCC_TRUE@	if $(COMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ $<; \
+@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c $<
+
+.c.obj:
+@am__fastdepCC_TRUE@	if $(COMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ `$(CYGPATH_W) '$<'`; \
+@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c `$(CYGPATH_W) '$<'`
+
+.c.lo:
+@am__fastdepCC_TRUE@	if $(LTCOMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ $<; \
+@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Plo"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LTCOMPILE) -c -o $@ $<
+
+adler32.lo: src/adler32.c
+@am__fastdepCC_TRUE@	if $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT adler32.lo -MD -MP -MF "$(DEPDIR)/adler32.Tpo" -c -o adler32.lo `test -f 'src/adler32.c' || echo '$(srcdir)/'`src/adler32.c; \
+@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/adler32.Tpo" "$(DEPDIR)/adler32.Plo"; else rm -f "$(DEPDIR)/adler32.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='src/adler32.c' object='adler32.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o adler32.lo `test -f 'src/adler32.c' || echo '$(srcdir)/'`src/adler32.c
+
+.cc.o:
+@am__fastdepCXX_TRUE@	if $(CXXCOMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ $<; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@	if $(CXXCOMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ `$(CYGPATH_W) '$<'`; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@	if $(LTCXXCOMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ $<; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Plo"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LTCXXCOMPILE) -c -o $@ $<
+
+gflags.lo: src/gflags.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT gflags.lo -MD -MP -MF "$(DEPDIR)/gflags.Tpo" -c -o gflags.lo `test -f 'src/gflags.cc' || echo '$(srcdir)/'`src/gflags.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/gflags.Tpo" "$(DEPDIR)/gflags.Plo"; else rm -f "$(DEPDIR)/gflags.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/gflags.cc' object='gflags.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o gflags.lo `test -f 'src/gflags.cc' || echo '$(srcdir)/'`src/gflags.cc
+
+gflags_reporting.lo: src/gflags_reporting.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT gflags_reporting.lo -MD -MP -MF "$(DEPDIR)/gflags_reporting.Tpo" -c -o gflags_reporting.lo `test -f 'src/gflags_reporting.cc' || echo '$(srcdir)/'`src/gflags_reporting.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/gflags_reporting.Tpo" "$(DEPDIR)/gflags_reporting.Plo"; else rm -f "$(DEPDIR)/gflags_reporting.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/gflags_reporting.cc' object='gflags_reporting.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o gflags_reporting.lo `test -f 'src/gflags_reporting.cc' || echo '$(srcdir)/'`src/gflags_reporting.cc
+
+gtest.lo: src/gtest/gtest.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT gtest.lo -MD -MP -MF "$(DEPDIR)/gtest.Tpo" -c -o gtest.lo `test -f 'src/gtest/gtest.cc' || echo '$(srcdir)/'`src/gtest/gtest.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/gtest.Tpo" "$(DEPDIR)/gtest.Plo"; else rm -f "$(DEPDIR)/gtest.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/gtest/gtest.cc' object='gtest.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o gtest.lo `test -f 'src/gtest/gtest.cc' || echo '$(srcdir)/'`src/gtest/gtest.cc
+
+gtest-death-test.lo: src/gtest/gtest-death-test.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT gtest-death-test.lo -MD -MP -MF "$(DEPDIR)/gtest-death-test.Tpo" -c -o gtest-death-test.lo `test -f 'src/gtest/gtest-death-test.cc' || echo '$(srcdir)/'`src/gtest/gtest-death-test.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/gtest-death-test.Tpo" "$(DEPDIR)/gtest-death-test.Plo"; else rm -f "$(DEPDIR)/gtest-death-test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/gtest/gtest-death-test.cc' object='gtest-death-test.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o gtest-death-test.lo `test -f 'src/gtest/gtest-death-test.cc' || echo '$(srcdir)/'`src/gtest/gtest-death-test.cc
+
+gtest-filepath.lo: src/gtest/gtest-filepath.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT gtest-filepath.lo -MD -MP -MF "$(DEPDIR)/gtest-filepath.Tpo" -c -o gtest-filepath.lo `test -f 'src/gtest/gtest-filepath.cc' || echo '$(srcdir)/'`src/gtest/gtest-filepath.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/gtest-filepath.Tpo" "$(DEPDIR)/gtest-filepath.Plo"; else rm -f "$(DEPDIR)/gtest-filepath.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/gtest/gtest-filepath.cc' object='gtest-filepath.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o gtest-filepath.lo `test -f 'src/gtest/gtest-filepath.cc' || echo '$(srcdir)/'`src/gtest/gtest-filepath.cc
+
+gtest-port.lo: src/gtest/gtest-port.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT gtest-port.lo -MD -MP -MF "$(DEPDIR)/gtest-port.Tpo" -c -o gtest-port.lo `test -f 'src/gtest/gtest-port.cc' || echo '$(srcdir)/'`src/gtest/gtest-port.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/gtest-port.Tpo" "$(DEPDIR)/gtest-port.Plo"; else rm -f "$(DEPDIR)/gtest-port.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/gtest/gtest-port.cc' object='gtest-port.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o gtest-port.lo `test -f 'src/gtest/gtest-port.cc' || echo '$(srcdir)/'`src/gtest/gtest-port.cc
+
+gtest_main.lo: src/gtest/gtest_main.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT gtest_main.lo -MD -MP -MF "$(DEPDIR)/gtest_main.Tpo" -c -o gtest_main.lo `test -f 'src/gtest/gtest_main.cc' || echo '$(srcdir)/'`src/gtest/gtest_main.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/gtest_main.Tpo" "$(DEPDIR)/gtest_main.Plo"; else rm -f "$(DEPDIR)/gtest_main.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/gtest/gtest_main.cc' object='gtest_main.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o gtest_main.lo `test -f 'src/gtest/gtest_main.cc' || echo '$(srcdir)/'`src/gtest/gtest_main.cc
+
+addrcache.lo: src/addrcache.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT addrcache.lo -MD -MP -MF "$(DEPDIR)/addrcache.Tpo" -c -o addrcache.lo `test -f 'src/addrcache.cc' || echo '$(srcdir)/'`src/addrcache.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/addrcache.Tpo" "$(DEPDIR)/addrcache.Plo"; else rm -f "$(DEPDIR)/addrcache.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/addrcache.cc' object='addrcache.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o addrcache.lo `test -f 'src/addrcache.cc' || echo '$(srcdir)/'`src/addrcache.cc
+
+codetable.lo: src/codetable.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT codetable.lo -MD -MP -MF "$(DEPDIR)/codetable.Tpo" -c -o codetable.lo `test -f 'src/codetable.cc' || echo '$(srcdir)/'`src/codetable.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/codetable.Tpo" "$(DEPDIR)/codetable.Plo"; else rm -f "$(DEPDIR)/codetable.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/codetable.cc' object='codetable.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o codetable.lo `test -f 'src/codetable.cc' || echo '$(srcdir)/'`src/codetable.cc
+
+logging.lo: src/logging.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT logging.lo -MD -MP -MF "$(DEPDIR)/logging.Tpo" -c -o logging.lo `test -f 'src/logging.cc' || echo '$(srcdir)/'`src/logging.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/logging.Tpo" "$(DEPDIR)/logging.Plo"; else rm -f "$(DEPDIR)/logging.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/logging.cc' object='logging.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o logging.lo `test -f 'src/logging.cc' || echo '$(srcdir)/'`src/logging.cc
+
+varint_bigendian.lo: src/varint_bigendian.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT varint_bigendian.lo -MD -MP -MF "$(DEPDIR)/varint_bigendian.Tpo" -c -o varint_bigendian.lo `test -f 'src/varint_bigendian.cc' || echo '$(srcdir)/'`src/varint_bigendian.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/varint_bigendian.Tpo" "$(DEPDIR)/varint_bigendian.Plo"; else rm -f "$(DEPDIR)/varint_bigendian.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/varint_bigendian.cc' object='varint_bigendian.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o varint_bigendian.lo `test -f 'src/varint_bigendian.cc' || echo '$(srcdir)/'`src/varint_bigendian.cc
+
+decodetable.lo: src/decodetable.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT decodetable.lo -MD -MP -MF "$(DEPDIR)/decodetable.Tpo" -c -o decodetable.lo `test -f 'src/decodetable.cc' || echo '$(srcdir)/'`src/decodetable.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/decodetable.Tpo" "$(DEPDIR)/decodetable.Plo"; else rm -f "$(DEPDIR)/decodetable.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/decodetable.cc' object='decodetable.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o decodetable.lo `test -f 'src/decodetable.cc' || echo '$(srcdir)/'`src/decodetable.cc
+
+headerparser.lo: src/headerparser.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT headerparser.lo -MD -MP -MF "$(DEPDIR)/headerparser.Tpo" -c -o headerparser.lo `test -f 'src/headerparser.cc' || echo '$(srcdir)/'`src/headerparser.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/headerparser.Tpo" "$(DEPDIR)/headerparser.Plo"; else rm -f "$(DEPDIR)/headerparser.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/headerparser.cc' object='headerparser.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o headerparser.lo `test -f 'src/headerparser.cc' || echo '$(srcdir)/'`src/headerparser.cc
+
+vcdecoder.lo: src/vcdecoder.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT vcdecoder.lo -MD -MP -MF "$(DEPDIR)/vcdecoder.Tpo" -c -o vcdecoder.lo `test -f 'src/vcdecoder.cc' || echo '$(srcdir)/'`src/vcdecoder.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/vcdecoder.Tpo" "$(DEPDIR)/vcdecoder.Plo"; else rm -f "$(DEPDIR)/vcdecoder.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/vcdecoder.cc' object='vcdecoder.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o vcdecoder.lo `test -f 'src/vcdecoder.cc' || echo '$(srcdir)/'`src/vcdecoder.cc
+
+blockhash.lo: src/blockhash.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT blockhash.lo -MD -MP -MF "$(DEPDIR)/blockhash.Tpo" -c -o blockhash.lo `test -f 'src/blockhash.cc' || echo '$(srcdir)/'`src/blockhash.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/blockhash.Tpo" "$(DEPDIR)/blockhash.Plo"; else rm -f "$(DEPDIR)/blockhash.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/blockhash.cc' object='blockhash.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o blockhash.lo `test -f 'src/blockhash.cc' || echo '$(srcdir)/'`src/blockhash.cc
+
+encodetable.lo: src/encodetable.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT encodetable.lo -MD -MP -MF "$(DEPDIR)/encodetable.Tpo" -c -o encodetable.lo `test -f 'src/encodetable.cc' || echo '$(srcdir)/'`src/encodetable.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/encodetable.Tpo" "$(DEPDIR)/encodetable.Plo"; else rm -f "$(DEPDIR)/encodetable.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/encodetable.cc' object='encodetable.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o encodetable.lo `test -f 'src/encodetable.cc' || echo '$(srcdir)/'`src/encodetable.cc
+
+vcdiffengine.lo: src/vcdiffengine.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT vcdiffengine.lo -MD -MP -MF "$(DEPDIR)/vcdiffengine.Tpo" -c -o vcdiffengine.lo `test -f 'src/vcdiffengine.cc' || echo '$(srcdir)/'`src/vcdiffengine.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/vcdiffengine.Tpo" "$(DEPDIR)/vcdiffengine.Plo"; else rm -f "$(DEPDIR)/vcdiffengine.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/vcdiffengine.cc' object='vcdiffengine.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o vcdiffengine.lo `test -f 'src/vcdiffengine.cc' || echo '$(srcdir)/'`src/vcdiffengine.cc
+
+vcencoder.lo: src/vcencoder.cc
+@am__fastdepCXX_TRUE@	if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT vcencoder.lo -MD -MP -MF "$(DEPDIR)/vcencoder.Tpo" -c -o vcencoder.lo `test -f 'src/vcencoder.cc' || echo '$(srcdir)/'`src/vcencoder.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/vcencoder.Tpo" "$(DEPDIR)/vcencoder.Plo"; else rm -f "$(DEPDIR)/vcencoder.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/vcencoder.cc' object='vcencoder.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o vcencoder.lo `test -f 'src/vcencoder.cc' || echo '$(srcdir)/'`src/vcencoder.cc
+
+addrcache_test.o: src/addrcache_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT addrcache_test.o -MD -MP -MF "$(DEPDIR)/addrcache_test.Tpo" -c -o addrcache_test.o `test -f 'src/addrcache_test.cc' || echo '$(srcdir)/'`src/addrcache_test.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/addrcache_test.Tpo" "$(DEPDIR)/addrcache_test.Po"; else rm -f "$(DEPDIR)/addrcache_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/addrcache_test.cc' object='addrcache_test.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o addrcache_test.o `test -f 'src/addrcache_test.cc' || echo '$(srcdir)/'`src/addrcache_test.cc
+
+addrcache_test.obj: src/addrcache_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT addrcache_test.obj -MD -MP -MF "$(DEPDIR)/addrcache_test.Tpo" -c -o addrcache_test.obj `if test -f 'src/addrcache_test.cc'; then $(CYGPATH_W) 'src/addrcache_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/addrcache_test.cc'; fi`; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/addrcache_test.Tpo" "$(DEPDIR)/addrcache_test.Po"; else rm -f "$(DEPDIR)/addrcache_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/addrcache_test.cc' object='addrcache_test.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o addrcache_test.obj `if test -f 'src/addrcache_test.cc'; then $(CYGPATH_W) 'src/addrcache_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/addrcache_test.cc'; fi`
+
+blockhash_test.o: src/blockhash_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT blockhash_test.o -MD -MP -MF "$(DEPDIR)/blockhash_test.Tpo" -c -o blockhash_test.o `test -f 'src/blockhash_test.cc' || echo '$(srcdir)/'`src/blockhash_test.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/blockhash_test.Tpo" "$(DEPDIR)/blockhash_test.Po"; else rm -f "$(DEPDIR)/blockhash_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/blockhash_test.cc' object='blockhash_test.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o blockhash_test.o `test -f 'src/blockhash_test.cc' || echo '$(srcdir)/'`src/blockhash_test.cc
+
+blockhash_test.obj: src/blockhash_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT blockhash_test.obj -MD -MP -MF "$(DEPDIR)/blockhash_test.Tpo" -c -o blockhash_test.obj `if test -f 'src/blockhash_test.cc'; then $(CYGPATH_W) 'src/blockhash_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/blockhash_test.cc'; fi`; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/blockhash_test.Tpo" "$(DEPDIR)/blockhash_test.Po"; else rm -f "$(DEPDIR)/blockhash_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/blockhash_test.cc' object='blockhash_test.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o blockhash_test.obj `if test -f 'src/blockhash_test.cc'; then $(CYGPATH_W) 'src/blockhash_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/blockhash_test.cc'; fi`
+
+codetable_test.o: src/codetable_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT codetable_test.o -MD -MP -MF "$(DEPDIR)/codetable_test.Tpo" -c -o codetable_test.o `test -f 'src/codetable_test.cc' || echo '$(srcdir)/'`src/codetable_test.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/codetable_test.Tpo" "$(DEPDIR)/codetable_test.Po"; else rm -f "$(DEPDIR)/codetable_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/codetable_test.cc' object='codetable_test.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o codetable_test.o `test -f 'src/codetable_test.cc' || echo '$(srcdir)/'`src/codetable_test.cc
+
+codetable_test.obj: src/codetable_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT codetable_test.obj -MD -MP -MF "$(DEPDIR)/codetable_test.Tpo" -c -o codetable_test.obj `if test -f 'src/codetable_test.cc'; then $(CYGPATH_W) 'src/codetable_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/codetable_test.cc'; fi`; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/codetable_test.Tpo" "$(DEPDIR)/codetable_test.Po"; else rm -f "$(DEPDIR)/codetable_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/codetable_test.cc' object='codetable_test.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o codetable_test.obj `if test -f 'src/codetable_test.cc'; then $(CYGPATH_W) 'src/codetable_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/codetable_test.cc'; fi`
+
+decodetable_test.o: src/decodetable_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT decodetable_test.o -MD -MP -MF "$(DEPDIR)/decodetable_test.Tpo" -c -o decodetable_test.o `test -f 'src/decodetable_test.cc' || echo '$(srcdir)/'`src/decodetable_test.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/decodetable_test.Tpo" "$(DEPDIR)/decodetable_test.Po"; else rm -f "$(DEPDIR)/decodetable_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/decodetable_test.cc' object='decodetable_test.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o decodetable_test.o `test -f 'src/decodetable_test.cc' || echo '$(srcdir)/'`src/decodetable_test.cc
+
+decodetable_test.obj: src/decodetable_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT decodetable_test.obj -MD -MP -MF "$(DEPDIR)/decodetable_test.Tpo" -c -o decodetable_test.obj `if test -f 'src/decodetable_test.cc'; then $(CYGPATH_W) 'src/decodetable_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/decodetable_test.cc'; fi`; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/decodetable_test.Tpo" "$(DEPDIR)/decodetable_test.Po"; else rm -f "$(DEPDIR)/decodetable_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/decodetable_test.cc' object='decodetable_test.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o decodetable_test.obj `if test -f 'src/decodetable_test.cc'; then $(CYGPATH_W) 'src/decodetable_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/decodetable_test.cc'; fi`
+
+encodetable_test.o: src/encodetable_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT encodetable_test.o -MD -MP -MF "$(DEPDIR)/encodetable_test.Tpo" -c -o encodetable_test.o `test -f 'src/encodetable_test.cc' || echo '$(srcdir)/'`src/encodetable_test.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/encodetable_test.Tpo" "$(DEPDIR)/encodetable_test.Po"; else rm -f "$(DEPDIR)/encodetable_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/encodetable_test.cc' object='encodetable_test.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o encodetable_test.o `test -f 'src/encodetable_test.cc' || echo '$(srcdir)/'`src/encodetable_test.cc
+
+encodetable_test.obj: src/encodetable_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT encodetable_test.obj -MD -MP -MF "$(DEPDIR)/encodetable_test.Tpo" -c -o encodetable_test.obj `if test -f 'src/encodetable_test.cc'; then $(CYGPATH_W) 'src/encodetable_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/encodetable_test.cc'; fi`; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/encodetable_test.Tpo" "$(DEPDIR)/encodetable_test.Po"; else rm -f "$(DEPDIR)/encodetable_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/encodetable_test.cc' object='encodetable_test.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o encodetable_test.obj `if test -f 'src/encodetable_test.cc'; then $(CYGPATH_W) 'src/encodetable_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/encodetable_test.cc'; fi`
+
+headerparser_test.o: src/headerparser_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT headerparser_test.o -MD -MP -MF "$(DEPDIR)/headerparser_test.Tpo" -c -o headerparser_test.o `test -f 'src/headerparser_test.cc' || echo '$(srcdir)/'`src/headerparser_test.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/headerparser_test.Tpo" "$(DEPDIR)/headerparser_test.Po"; else rm -f "$(DEPDIR)/headerparser_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/headerparser_test.cc' object='headerparser_test.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o headerparser_test.o `test -f 'src/headerparser_test.cc' || echo '$(srcdir)/'`src/headerparser_test.cc
+
+headerparser_test.obj: src/headerparser_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT headerparser_test.obj -MD -MP -MF "$(DEPDIR)/headerparser_test.Tpo" -c -o headerparser_test.obj `if test -f 'src/headerparser_test.cc'; then $(CYGPATH_W) 'src/headerparser_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/headerparser_test.cc'; fi`; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/headerparser_test.Tpo" "$(DEPDIR)/headerparser_test.Po"; else rm -f "$(DEPDIR)/headerparser_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/headerparser_test.cc' object='headerparser_test.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o headerparser_test.obj `if test -f 'src/headerparser_test.cc'; then $(CYGPATH_W) 'src/headerparser_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/headerparser_test.cc'; fi`
+
+output_string_test.o: src/output_string_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT output_string_test.o -MD -MP -MF "$(DEPDIR)/output_string_test.Tpo" -c -o output_string_test.o `test -f 'src/output_string_test.cc' || echo '$(srcdir)/'`src/output_string_test.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/output_string_test.Tpo" "$(DEPDIR)/output_string_test.Po"; else rm -f "$(DEPDIR)/output_string_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/output_string_test.cc' object='output_string_test.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o output_string_test.o `test -f 'src/output_string_test.cc' || echo '$(srcdir)/'`src/output_string_test.cc
+
+output_string_test.obj: src/output_string_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT output_string_test.obj -MD -MP -MF "$(DEPDIR)/output_string_test.Tpo" -c -o output_string_test.obj `if test -f 'src/output_string_test.cc'; then $(CYGPATH_W) 'src/output_string_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/output_string_test.cc'; fi`; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/output_string_test.Tpo" "$(DEPDIR)/output_string_test.Po"; else rm -f "$(DEPDIR)/output_string_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/output_string_test.cc' object='output_string_test.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o output_string_test.obj `if test -f 'src/output_string_test.cc'; then $(CYGPATH_W) 'src/output_string_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/output_string_test.cc'; fi`
+
+rolling_hash_test.o: src/rolling_hash_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT rolling_hash_test.o -MD -MP -MF "$(DEPDIR)/rolling_hash_test.Tpo" -c -o rolling_hash_test.o `test -f 'src/rolling_hash_test.cc' || echo '$(srcdir)/'`src/rolling_hash_test.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/rolling_hash_test.Tpo" "$(DEPDIR)/rolling_hash_test.Po"; else rm -f "$(DEPDIR)/rolling_hash_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/rolling_hash_test.cc' object='rolling_hash_test.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o rolling_hash_test.o `test -f 'src/rolling_hash_test.cc' || echo '$(srcdir)/'`src/rolling_hash_test.cc
+
+rolling_hash_test.obj: src/rolling_hash_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT rolling_hash_test.obj -MD -MP -MF "$(DEPDIR)/rolling_hash_test.Tpo" -c -o rolling_hash_test.obj `if test -f 'src/rolling_hash_test.cc'; then $(CYGPATH_W) 'src/rolling_hash_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/rolling_hash_test.cc'; fi`; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/rolling_hash_test.Tpo" "$(DEPDIR)/rolling_hash_test.Po"; else rm -f "$(DEPDIR)/rolling_hash_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/rolling_hash_test.cc' object='rolling_hash_test.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o rolling_hash_test.obj `if test -f 'src/rolling_hash_test.cc'; then $(CYGPATH_W) 'src/rolling_hash_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/rolling_hash_test.cc'; fi`
+
+varint_bigendian_test.o: src/varint_bigendian_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT varint_bigendian_test.o -MD -MP -MF "$(DEPDIR)/varint_bigendian_test.Tpo" -c -o varint_bigendian_test.o `test -f 'src/varint_bigendian_test.cc' || echo '$(srcdir)/'`src/varint_bigendian_test.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/varint_bigendian_test.Tpo" "$(DEPDIR)/varint_bigendian_test.Po"; else rm -f "$(DEPDIR)/varint_bigendian_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/varint_bigendian_test.cc' object='varint_bigendian_test.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o varint_bigendian_test.o `test -f 'src/varint_bigendian_test.cc' || echo '$(srcdir)/'`src/varint_bigendian_test.cc
+
+varint_bigendian_test.obj: src/varint_bigendian_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT varint_bigendian_test.obj -MD -MP -MF "$(DEPDIR)/varint_bigendian_test.Tpo" -c -o varint_bigendian_test.obj `if test -f 'src/varint_bigendian_test.cc'; then $(CYGPATH_W) 'src/varint_bigendian_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/varint_bigendian_test.cc'; fi`; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/varint_bigendian_test.Tpo" "$(DEPDIR)/varint_bigendian_test.Po"; else rm -f "$(DEPDIR)/varint_bigendian_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/varint_bigendian_test.cc' object='varint_bigendian_test.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o varint_bigendian_test.obj `if test -f 'src/varint_bigendian_test.cc'; then $(CYGPATH_W) 'src/varint_bigendian_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/varint_bigendian_test.cc'; fi`
+
+vcdecoder_test.o: src/vcdecoder_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT vcdecoder_test.o -MD -MP -MF "$(DEPDIR)/vcdecoder_test.Tpo" -c -o vcdecoder_test.o `test -f 'src/vcdecoder_test.cc' || echo '$(srcdir)/'`src/vcdecoder_test.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/vcdecoder_test.Tpo" "$(DEPDIR)/vcdecoder_test.Po"; else rm -f "$(DEPDIR)/vcdecoder_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/vcdecoder_test.cc' object='vcdecoder_test.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o vcdecoder_test.o `test -f 'src/vcdecoder_test.cc' || echo '$(srcdir)/'`src/vcdecoder_test.cc
+
+vcdecoder_test.obj: src/vcdecoder_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT vcdecoder_test.obj -MD -MP -MF "$(DEPDIR)/vcdecoder_test.Tpo" -c -o vcdecoder_test.obj `if test -f 'src/vcdecoder_test.cc'; then $(CYGPATH_W) 'src/vcdecoder_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/vcdecoder_test.cc'; fi`; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/vcdecoder_test.Tpo" "$(DEPDIR)/vcdecoder_test.Po"; else rm -f "$(DEPDIR)/vcdecoder_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/vcdecoder_test.cc' object='vcdecoder_test.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o vcdecoder_test.obj `if test -f 'src/vcdecoder_test.cc'; then $(CYGPATH_W) 'src/vcdecoder_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/vcdecoder_test.cc'; fi`
+
+vcdiff_main.o: src/vcdiff_main.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT vcdiff_main.o -MD -MP -MF "$(DEPDIR)/vcdiff_main.Tpo" -c -o vcdiff_main.o `test -f 'src/vcdiff_main.cc' || echo '$(srcdir)/'`src/vcdiff_main.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/vcdiff_main.Tpo" "$(DEPDIR)/vcdiff_main.Po"; else rm -f "$(DEPDIR)/vcdiff_main.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/vcdiff_main.cc' object='vcdiff_main.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o vcdiff_main.o `test -f 'src/vcdiff_main.cc' || echo '$(srcdir)/'`src/vcdiff_main.cc
+
+vcdiff_main.obj: src/vcdiff_main.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT vcdiff_main.obj -MD -MP -MF "$(DEPDIR)/vcdiff_main.Tpo" -c -o vcdiff_main.obj `if test -f 'src/vcdiff_main.cc'; then $(CYGPATH_W) 'src/vcdiff_main.cc'; else $(CYGPATH_W) '$(srcdir)/src/vcdiff_main.cc'; fi`; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/vcdiff_main.Tpo" "$(DEPDIR)/vcdiff_main.Po"; else rm -f "$(DEPDIR)/vcdiff_main.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/vcdiff_main.cc' object='vcdiff_main.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o vcdiff_main.obj `if test -f 'src/vcdiff_main.cc'; then $(CYGPATH_W) 'src/vcdiff_main.cc'; else $(CYGPATH_W) '$(srcdir)/src/vcdiff_main.cc'; fi`
+
+vcdiffengine_test.o: src/vcdiffengine_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT vcdiffengine_test.o -MD -MP -MF "$(DEPDIR)/vcdiffengine_test.Tpo" -c -o vcdiffengine_test.o `test -f 'src/vcdiffengine_test.cc' || echo '$(srcdir)/'`src/vcdiffengine_test.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/vcdiffengine_test.Tpo" "$(DEPDIR)/vcdiffengine_test.Po"; else rm -f "$(DEPDIR)/vcdiffengine_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/vcdiffengine_test.cc' object='vcdiffengine_test.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o vcdiffengine_test.o `test -f 'src/vcdiffengine_test.cc' || echo '$(srcdir)/'`src/vcdiffengine_test.cc
+
+vcdiffengine_test.obj: src/vcdiffengine_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT vcdiffengine_test.obj -MD -MP -MF "$(DEPDIR)/vcdiffengine_test.Tpo" -c -o vcdiffengine_test.obj `if test -f 'src/vcdiffengine_test.cc'; then $(CYGPATH_W) 'src/vcdiffengine_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/vcdiffengine_test.cc'; fi`; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/vcdiffengine_test.Tpo" "$(DEPDIR)/vcdiffengine_test.Po"; else rm -f "$(DEPDIR)/vcdiffengine_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/vcdiffengine_test.cc' object='vcdiffengine_test.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o vcdiffengine_test.obj `if test -f 'src/vcdiffengine_test.cc'; then $(CYGPATH_W) 'src/vcdiffengine_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/vcdiffengine_test.cc'; fi`
+
+vcencoder_test.o: src/vcencoder_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT vcencoder_test.o -MD -MP -MF "$(DEPDIR)/vcencoder_test.Tpo" -c -o vcencoder_test.o `test -f 'src/vcencoder_test.cc' || echo '$(srcdir)/'`src/vcencoder_test.cc; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/vcencoder_test.Tpo" "$(DEPDIR)/vcencoder_test.Po"; else rm -f "$(DEPDIR)/vcencoder_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/vcencoder_test.cc' object='vcencoder_test.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o vcencoder_test.o `test -f 'src/vcencoder_test.cc' || echo '$(srcdir)/'`src/vcencoder_test.cc
+
+vcencoder_test.obj: src/vcencoder_test.cc
+@am__fastdepCXX_TRUE@	if $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT vcencoder_test.obj -MD -MP -MF "$(DEPDIR)/vcencoder_test.Tpo" -c -o vcencoder_test.obj `if test -f 'src/vcencoder_test.cc'; then $(CYGPATH_W) 'src/vcencoder_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/vcencoder_test.cc'; fi`; \
+@am__fastdepCXX_TRUE@	then mv -f "$(DEPDIR)/vcencoder_test.Tpo" "$(DEPDIR)/vcencoder_test.Po"; else rm -f "$(DEPDIR)/vcencoder_test.Tpo"; exit 1; fi
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='src/vcencoder_test.cc' object='vcencoder_test.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o vcencoder_test.obj `if test -f 'src/vcencoder_test.cc'; then $(CYGPATH_W) 'src/vcencoder_test.cc'; else $(CYGPATH_W) '$(srcdir)/src/vcencoder_test.cc'; fi`
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+distclean-libtool:
+	-rm -f libtool
+uninstall-info-am:
+install-dist_docDATA: $(dist_doc_DATA)
+	@$(NORMAL_INSTALL)
+	test -z "$(docdir)" || $(mkdir_p) "$(DESTDIR)$(docdir)"
+	@list='$(dist_doc_DATA)'; for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  f=$(am__strip_dir) \
+	  echo " $(dist_docDATA_INSTALL) '$$d$$p' '$(DESTDIR)$(docdir)/$$f'"; \
+	  $(dist_docDATA_INSTALL) "$$d$$p" "$(DESTDIR)$(docdir)/$$f"; \
+	done
+
+uninstall-dist_docDATA:
+	@$(NORMAL_UNINSTALL)
+	@list='$(dist_doc_DATA)'; for p in $$list; do \
+	  f=$(am__strip_dir) \
+	  echo " rm -f '$(DESTDIR)$(docdir)/$$f'"; \
+	  rm -f "$(DESTDIR)$(docdir)/$$f"; \
+	done
+install-googleincludeHEADERS: $(googleinclude_HEADERS)
+	@$(NORMAL_INSTALL)
+	test -z "$(googleincludedir)" || $(mkdir_p) "$(DESTDIR)$(googleincludedir)"
+	@list='$(googleinclude_HEADERS)'; for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  f=$(am__strip_dir) \
+	  echo " $(googleincludeHEADERS_INSTALL) '$$d$$p' '$(DESTDIR)$(googleincludedir)/$$f'"; \
+	  $(googleincludeHEADERS_INSTALL) "$$d$$p" "$(DESTDIR)$(googleincludedir)/$$f"; \
+	done
+
+uninstall-googleincludeHEADERS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(googleinclude_HEADERS)'; for p in $$list; do \
+	  f=$(am__strip_dir) \
+	  echo " rm -f '$(DESTDIR)$(googleincludedir)/$$f'"; \
+	  rm -f "$(DESTDIR)$(googleincludedir)/$$f"; \
+	done
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	    $$tags $$unique; \
+	fi
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(CTAGS_ARGS)$$tags$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$tags $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && cd $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) $$here
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+check-TESTS: $(TESTS)
+	@failed=0; all=0; xfail=0; xpass=0; skip=0; \
+	srcdir=$(srcdir); export srcdir; \
+	list='$(TESTS)'; \
+	if test -n "$$list"; then \
+	  for tst in $$list; do \
+	    if test -f ./$$tst; then dir=./; \
+	    elif test -f $$tst; then dir=; \
+	    else dir="$(srcdir)/"; fi; \
+	    if $(TESTS_ENVIRONMENT) $${dir}$$tst; then \
+	      all=`expr $$all + 1`; \
+	      case " $(XFAIL_TESTS) " in \
+	      *" $$tst "*) \
+		xpass=`expr $$xpass + 1`; \
+		failed=`expr $$failed + 1`; \
+		echo "XPASS: $$tst"; \
+	      ;; \
+	      *) \
+		echo "PASS: $$tst"; \
+	      ;; \
+	      esac; \
+	    elif test $$? -ne 77; then \
+	      all=`expr $$all + 1`; \
+	      case " $(XFAIL_TESTS) " in \
+	      *" $$tst "*) \
+		xfail=`expr $$xfail + 1`; \
+		echo "XFAIL: $$tst"; \
+	      ;; \
+	      *) \
+		failed=`expr $$failed + 1`; \
+		echo "FAIL: $$tst"; \
+	      ;; \
+	      esac; \
+	    else \
+	      skip=`expr $$skip + 1`; \
+	      echo "SKIP: $$tst"; \
+	    fi; \
+	  done; \
+	  if test "$$failed" -eq 0; then \
+	    if test "$$xfail" -eq 0; then \
+	      banner="All $$all tests passed"; \
+	    else \
+	      banner="All $$all tests behaved as expected ($$xfail expected failures)"; \
+	    fi; \
+	  else \
+	    if test "$$xpass" -eq 0; then \
+	      banner="$$failed of $$all tests failed"; \
+	    else \
+	      banner="$$failed of $$all tests did not behave as expected ($$xpass unexpected passes)"; \
+	    fi; \
+	  fi; \
+	  dashes="$$banner"; \
+	  skipped=""; \
+	  if test "$$skip" -ne 0; then \
+	    skipped="($$skip tests were not run)"; \
+	    test `echo "$$skipped" | wc -c` -le `echo "$$banner" | wc -c` || \
+	      dashes="$$skipped"; \
+	  fi; \
+	  report=""; \
+	  if test "$$failed" -ne 0 && test -n "$(PACKAGE_BUGREPORT)"; then \
+	    report="Please report to $(PACKAGE_BUGREPORT)"; \
+	    test `echo "$$report" | wc -c` -le `echo "$$banner" | wc -c` || \
+	      dashes="$$report"; \
+	  fi; \
+	  dashes=`echo "$$dashes" | sed s/./=/g`; \
+	  echo "$$dashes"; \
+	  echo "$$banner"; \
+	  test -z "$$skipped" || echo "$$skipped"; \
+	  test -z "$$report" || echo "$$report"; \
+	  echo "$$dashes"; \
+	  test "$$failed" -eq 0; \
+	else :; fi
+
+distdir: $(DISTFILES)
+	$(am__remove_distdir)
+	mkdir $(distdir)
+	$(mkdir_p) $(distdir)/m4 $(distdir)/packages $(distdir)/packages/rpm $(distdir)/src $(distdir)/src/google
+	@srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \
+	list='$(DISTFILES)'; for file in $$list; do \
+	  case $$file in \
+	    $(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \
+	    $(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \
+	  esac; \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \
+	  if test "$$dir" != "$$file" && test "$$dir" != "."; then \
+	    dir="/$$dir"; \
+	    $(mkdir_p) "$(distdir)$$dir"; \
+	  else \
+	    dir=''; \
+	  fi; \
+	  if test -d $$d/$$file; then \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
+	    fi; \
+	    cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
+	  else \
+	    test -f $(distdir)/$$file \
+	    || cp -p $$d/$$file $(distdir)/$$file \
+	    || exit 1; \
+	  fi; \
+	done
+	-find $(distdir) -type d ! -perm -777 -exec chmod a+rwx {} \; -o \
+	  ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \
+	  ! -type d ! -perm -400 -exec chmod a+r {} \; -o \
+	  ! -type d ! -perm -444 -exec $(SHELL) $(install_sh) -c -m a+r {} {} \; \
+	|| chmod -R a+r $(distdir)
+dist-gzip: distdir
+	tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
+	$(am__remove_distdir)
+
+dist-bzip2: distdir
+	tardir=$(distdir) && $(am__tar) | bzip2 -9 -c >$(distdir).tar.bz2
+	$(am__remove_distdir)
+
+dist-tarZ: distdir
+	tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
+	$(am__remove_distdir)
+
+dist-shar: distdir
+	shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz
+	$(am__remove_distdir)
+
+dist-zip: distdir
+	-rm -f $(distdir).zip
+	zip -rq $(distdir).zip $(distdir)
+	$(am__remove_distdir)
+
+dist dist-all: distdir
+	tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
+	$(am__remove_distdir)
+
+# This target untars the dist file and tries a VPATH configuration.  Then
+# it guarantees that the distribution is self-contained by making another
+# tarfile.
+distcheck: dist
+	case '$(DIST_ARCHIVES)' in \
+	*.tar.gz*) \
+	  GZIP=$(GZIP_ENV) gunzip -c $(distdir).tar.gz | $(am__untar) ;;\
+	*.tar.bz2*) \
+	  bunzip2 -c $(distdir).tar.bz2 | $(am__untar) ;;\
+	*.tar.Z*) \
+	  uncompress -c $(distdir).tar.Z | $(am__untar) ;;\
+	*.shar.gz*) \
+	  GZIP=$(GZIP_ENV) gunzip -c $(distdir).shar.gz | unshar ;;\
+	*.zip*) \
+	  unzip $(distdir).zip ;;\
+	esac
+	chmod -R a-w $(distdir); chmod a+w $(distdir)
+	mkdir $(distdir)/_build
+	mkdir $(distdir)/_inst
+	chmod a-w $(distdir)
+	dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \
+	  && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \
+	  && cd $(distdir)/_build \
+	  && ../configure --srcdir=.. --prefix="$$dc_install_base" \
+	    $(DISTCHECK_CONFIGURE_FLAGS) \
+	  && $(MAKE) $(AM_MAKEFLAGS) \
+	  && $(MAKE) $(AM_MAKEFLAGS) dvi \
+	  && $(MAKE) $(AM_MAKEFLAGS) check \
+	  && $(MAKE) $(AM_MAKEFLAGS) install \
+	  && $(MAKE) $(AM_MAKEFLAGS) installcheck \
+	  && $(MAKE) $(AM_MAKEFLAGS) uninstall \
+	  && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \
+	        distuninstallcheck \
+	  && chmod -R a-w "$$dc_install_base" \
+	  && ({ \
+	       (cd ../.. && umask 077 && mkdir "$$dc_destdir") \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \
+	            distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \
+	      } || { rm -rf "$$dc_destdir"; exit 1; }) \
+	  && rm -rf "$$dc_destdir" \
+	  && $(MAKE) $(AM_MAKEFLAGS) dist \
+	  && rm -rf $(DIST_ARCHIVES) \
+	  && $(MAKE) $(AM_MAKEFLAGS) distcleancheck
+	$(am__remove_distdir)
+	@(echo "$(distdir) archives ready for distribution: "; \
+	  list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \
+	  sed -e '1{h;s/./=/g;p;x;}' -e '$${p;x;}'
+distuninstallcheck:
+	@cd $(distuninstallcheck_dir) \
+	&& test `$(distuninstallcheck_listfiles) | wc -l` -le 1 \
+	   || { echo "ERROR: files left after uninstall:" ; \
+	        if test -n "$(DESTDIR)"; then \
+	          echo "  (check DESTDIR support)"; \
+	        fi ; \
+	        $(distuninstallcheck_listfiles) ; \
+	        exit 1; } >&2
+distcleancheck: distclean
+	@if test '$(srcdir)' = . ; then \
+	  echo "ERROR: distcleancheck can only run from a VPATH build" ; \
+	  exit 1 ; \
+	fi
+	@test `$(distcleancheck_listfiles) | wc -l` -eq 0 \
+	  || { echo "ERROR: files left in build directory after distclean:" ; \
+	       $(distcleancheck_listfiles) ; \
+	       exit 1; } >&2
+check-am: all-am
+	$(MAKE) $(AM_MAKEFLAGS) $(check_SCRIPTS)
+	$(MAKE) $(AM_MAKEFLAGS) check-TESTS
+check: check-am
+all-am: Makefile $(LTLIBRARIES) $(PROGRAMS) $(SCRIPTS) $(DATA) \
+		$(HEADERS)
+install-binPROGRAMS: install-libLTLIBRARIES
+
+installdirs:
+	for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)" "$(DESTDIR)$(docdir)" "$(DESTDIR)$(googleincludedir)"; do \
+	  test -z "$$dir" || $(mkdir_p) "$$dir"; \
+	done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \
+	clean-libtool clean-noinstLTLIBRARIES clean-noinstPROGRAMS \
+	mostlyclean-am
+
+distclean: distclean-am
+	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-hdr distclean-libtool distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+info: info-am
+
+info-am:
+
+install-data-am: install-dist_docDATA install-googleincludeHEADERS
+
+install-exec-am: install-binPROGRAMS install-libLTLIBRARIES
+
+install-info: install-info-am
+
+install-man:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
+	-rm -rf $(top_srcdir)/autom4te.cache
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-binPROGRAMS uninstall-dist_docDATA \
+	uninstall-googleincludeHEADERS uninstall-info-am \
+	uninstall-libLTLIBRARIES
+
+.PHONY: CTAGS GTAGS all all-am am--refresh check check-TESTS check-am \
+	clean clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \
+	clean-libtool clean-noinstLTLIBRARIES clean-noinstPROGRAMS \
+	ctags dist dist-all dist-bzip2 dist-gzip dist-shar dist-tarZ \
+	dist-zip distcheck distclean distclean-compile \
+	distclean-generic distclean-hdr distclean-libtool \
+	distclean-tags distcleancheck distdir distuninstallcheck dvi \
+	dvi-am html html-am info info-am install install-am \
+	install-binPROGRAMS install-data install-data-am \
+	install-dist_docDATA install-exec install-exec-am \
+	install-googleincludeHEADERS install-info install-info-am \
+	install-libLTLIBRARIES install-man install-strip installcheck \
+	installcheck-am installdirs maintainer-clean \
+	maintainer-clean-generic mostlyclean mostlyclean-compile \
+	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+	tags uninstall uninstall-am uninstall-binPROGRAMS \
+	uninstall-dist_docDATA uninstall-googleincludeHEADERS \
+	uninstall-info-am uninstall-libLTLIBRARIES
+
+
+rpm: dist-gzip packages/rpm.sh packages/rpm/rpm.spec
+	@cd packages && ./rpm.sh ${PACKAGE} ${VERSION}
+
+deb: dist-gzip packages/deb.sh packages/deb/*
+	@cd packages && ./deb.sh ${PACKAGE} ${VERSION}
+
+libtool: $(LIBTOOL_DEPS)
+	$(SHELL) ./config.status --recheck
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/NEWS b/sdch/open_vcdiff/depot/opensource/open-vcdiff/NEWS
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/NEWS
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/README b/sdch/open_vcdiff/depot/opensource/open-vcdiff/README
new file mode 100644
index 0000000..c67823b
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/README
@@ -0,0 +1,43 @@
+open-vcdiff is an encoder and decoder for the VCDIFF format, as described in
+RFC 3284 : The VCDIFF Generic Differencing and Compression Data Format
+(http://www.ietf.org/rfc/rfc3284.txt)
+A library with a simple API is included, as well as a command-line executable
+that can apply the encoder and decoder to source, target, and delta files.
+For further details, please refer to:
+http://code.google.com/p/open-vcdiff/wiki/HowToUseOpenVcdiff
+
+See INSTALL for (generic) installation instructions for C++: basically
+   ./configure && make && make install
+
+This should compile the unit tests as well as "vcdiff", a simple command-line
+utility to run the encoder and decoder.  Typical usage of vcdiff is as follows
+(the "<" and ">" are file redirect operations, not optional arguments):
+   vcdiff encode -dictionary file.dict < target_file > delta_file
+   vcdiff decode -dictionary file.dict < delta_file > target_file
+To see the command-line syntax of vcdiff, use "vcdiff --help" or just "vcdiff".
+
+To call the encoder from C++ code, assuming that dictionary, target, and delta
+are all std::string objects:
+#include <google/vcencoder.h>  // Read this file for interface details
+[...]
+  open_vcdiff::VCDiffEncoder encoder(dictionary.data(), dictionary.size());
+  encoder.SetFormatFlags(open_vcdiff::VCD_FORMAT_INTERLEAVED);
+  encoder.Encode(target.data(), target.size(), &delta);
+
+Calling the decoder is just as simple:
+#include <google/vcdecoder.h>  // Read this file for interface details
+[...]
+  open_vcdiff::VCDiffDecoder decoder;
+  decoder.Decode(dictionary.data(), dictionary.size(), delta, &target);
+
+When using the encoder, the C++ application must be linked with the library
+options -lvcdcom and -lvcdenc; when using the decoder, it must be linked with
+-lvcdcom and -lvcddec.
+
+To verify that the package works on your system, especially after making
+modifications to the source code, please run the unit tests using
+   make check
+
+For further details, please refer to:
+http://code.google.com/p/open-vcdiff/wiki/HowToUseOpenVcdiff
+
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/THANKS b/sdch/open_vcdiff/depot/opensource/open-vcdiff/THANKS
new file mode 100644
index 0000000..b67e60a
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/THANKS
@@ -0,0 +1,34 @@
+open-vcdiff has originally been written by Lincoln Smith with

+significant code contributions by Chandra Chereddi, Jeff Dean,

+Sanjay Ghemawat, Craig Silverstein, and Zhanyong Wan.  Special

+thanks to Craig Silverstein and Daniel Berlin as tireless

+champions of open-source projects.

+Many people further contributed to open-vcdiff by reporting

+problems, suggesting various improvements or submitting actual

+code.  Here is a list of these people. Help me keep it complete

+and free of errors.

+Daniel Berlin

+Jon Butler

+Wiltse Carpenter

+Jagannadh Chukka

+Eric Flatt

+David Glasser

+Bijun He

+Jacob Hoffman-Andrews

+Ashu Jain

+Leonidas Kontothanassis

+Michael Kleber

+Wei-Hsin Lee

+Frank Lin

+Josh MacDonald

+Bryan McQuade

+Ken Mixter

+Jim Morrison

+Alex Raikman

+David Rochberg

+Jim Roskind

+Robin Shostack

+Ben Smith

+Todd Turnidge

+Linus Upson

+

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/aclocal.m4 b/sdch/open_vcdiff/depot/opensource/open-vcdiff/aclocal.m4
new file mode 100644
index 0000000..1b131f1
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/aclocal.m4
@@ -0,0 +1,7269 @@
+# generated automatically by aclocal 1.9.6 -*- Autoconf -*-

+

+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,

+# 2005  Free Software Foundation, Inc.

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# This program is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without

+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A

+# PARTICULAR PURPOSE.

+

+# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-

+

+# serial 48 Debian 1.5.22-2 AC_PROG_LIBTOOL

+

+

+# AC_PROVIDE_IFELSE(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED)

+# -----------------------------------------------------------

+# If this macro is not defined by Autoconf, define it here.

+m4_ifdef([AC_PROVIDE_IFELSE],

+         [],

+         [m4_define([AC_PROVIDE_IFELSE],

+	         [m4_ifdef([AC_PROVIDE_$1],

+		           [$2], [$3])])])

+

+

+# AC_PROG_LIBTOOL

+# ---------------

+AC_DEFUN([AC_PROG_LIBTOOL],

+[AC_REQUIRE([_AC_PROG_LIBTOOL])dnl

+dnl If AC_PROG_CXX has already been expanded, run AC_LIBTOOL_CXX

+dnl immediately, otherwise, hook it in at the end of AC_PROG_CXX.

+  AC_PROVIDE_IFELSE([AC_PROG_CXX],

+    [AC_LIBTOOL_CXX],

+    [define([AC_PROG_CXX], defn([AC_PROG_CXX])[AC_LIBTOOL_CXX

+  ])])

+dnl And a similar setup for Fortran 77 support

+  AC_PROVIDE_IFELSE([AC_PROG_F77],

+    [AC_LIBTOOL_F77],

+    [define([AC_PROG_F77], defn([AC_PROG_F77])[AC_LIBTOOL_F77

+])])

+

+dnl Quote A][M_PROG_GCJ so that aclocal doesn't bring it in needlessly.

+dnl If either AC_PROG_GCJ or A][M_PROG_GCJ have already been expanded, run

+dnl AC_LIBTOOL_GCJ immediately, otherwise, hook it in at the end of both.

+  AC_PROVIDE_IFELSE([AC_PROG_GCJ],

+    [AC_LIBTOOL_GCJ],

+    [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],

+      [AC_LIBTOOL_GCJ],

+      [AC_PROVIDE_IFELSE([LT_AC_PROG_GCJ],

+	[AC_LIBTOOL_GCJ],

+      [ifdef([AC_PROG_GCJ],

+	     [define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[AC_LIBTOOL_GCJ])])

+       ifdef([A][M_PROG_GCJ],

+	     [define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[AC_LIBTOOL_GCJ])])

+       ifdef([LT_AC_PROG_GCJ],

+	     [define([LT_AC_PROG_GCJ],

+		defn([LT_AC_PROG_GCJ])[AC_LIBTOOL_GCJ])])])])

+])])# AC_PROG_LIBTOOL

+

+

+# _AC_PROG_LIBTOOL

+# ----------------

+AC_DEFUN([_AC_PROG_LIBTOOL],

+[AC_REQUIRE([AC_LIBTOOL_SETUP])dnl

+AC_BEFORE([$0],[AC_LIBTOOL_CXX])dnl

+AC_BEFORE([$0],[AC_LIBTOOL_F77])dnl

+AC_BEFORE([$0],[AC_LIBTOOL_GCJ])dnl

+

+# This can be used to rebuild libtool when needed

+LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh"

+

+# Always use our own libtool.

+LIBTOOL='$(SHELL) $(top_builddir)/libtool'

+AC_SUBST(LIBTOOL)dnl

+

+# Prevent multiple expansion

+define([AC_PROG_LIBTOOL], [])

+])# _AC_PROG_LIBTOOL

+

+

+# AC_LIBTOOL_SETUP

+# ----------------

+AC_DEFUN([AC_LIBTOOL_SETUP],

+[AC_PREREQ(2.50)dnl

+AC_REQUIRE([AC_ENABLE_SHARED])dnl

+AC_REQUIRE([AC_ENABLE_STATIC])dnl

+AC_REQUIRE([AC_ENABLE_FAST_INSTALL])dnl

+AC_REQUIRE([AC_CANONICAL_HOST])dnl

+AC_REQUIRE([AC_CANONICAL_BUILD])dnl

+AC_REQUIRE([AC_PROG_CC])dnl

+AC_REQUIRE([AC_PROG_LD])dnl

+AC_REQUIRE([AC_PROG_LD_RELOAD_FLAG])dnl

+AC_REQUIRE([AC_PROG_NM])dnl

+

+AC_REQUIRE([AC_PROG_LN_S])dnl

+AC_REQUIRE([AC_DEPLIBS_CHECK_METHOD])dnl

+# Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!

+AC_REQUIRE([AC_OBJEXT])dnl

+AC_REQUIRE([AC_EXEEXT])dnl

+dnl

+

+AC_LIBTOOL_SYS_MAX_CMD_LEN

+AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE

+AC_LIBTOOL_OBJDIR

+

+AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl

+_LT_AC_PROG_ECHO_BACKSLASH

+

+case $host_os in

+aix3*)

+  # AIX sometimes has problems with the GCC collect2 program.  For some

+  # reason, if we set the COLLECT_NAMES environment variable, the problems

+  # vanish in a puff of smoke.

+  if test "X${COLLECT_NAMES+set}" != Xset; then

+    COLLECT_NAMES=

+    export COLLECT_NAMES

+  fi

+  ;;

+esac

+

+# Sed substitution that helps us do robust quoting.  It backslashifies

+# metacharacters that are still active within double-quoted strings.

+Xsed='sed -e 1s/^X//'

+[sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g']

+

+# Same as above, but do not quote variable references.

+[double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g']

+

+# Sed substitution to delay expansion of an escaped shell variable in a

+# double_quote_subst'ed string.

+delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'

+

+# Sed substitution to avoid accidental globbing in evaled expressions

+no_glob_subst='s/\*/\\\*/g'

+

+# Constants:

+rm="rm -f"

+

+# Global variables:

+default_ofile=libtool

+can_build_shared=yes

+

+# All known linkers require a `.a' archive for static linking (except MSVC,

+# which needs '.lib').

+libext=a

+ltmain="$ac_aux_dir/ltmain.sh"

+ofile="$default_ofile"

+with_gnu_ld="$lt_cv_prog_gnu_ld"

+

+AC_CHECK_TOOL(AR, ar, false)

+AC_CHECK_TOOL(RANLIB, ranlib, :)

+AC_CHECK_TOOL(STRIP, strip, :)

+

+old_CC="$CC"

+old_CFLAGS="$CFLAGS"

+

+# Set sane defaults for various variables

+test -z "$AR" && AR=ar

+test -z "$AR_FLAGS" && AR_FLAGS=cru

+test -z "$AS" && AS=as

+test -z "$CC" && CC=cc

+test -z "$LTCC" && LTCC=$CC

+test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS

+test -z "$DLLTOOL" && DLLTOOL=dlltool

+test -z "$LD" && LD=ld

+test -z "$LN_S" && LN_S="ln -s"

+test -z "$MAGIC_CMD" && MAGIC_CMD=file

+test -z "$NM" && NM=nm

+test -z "$SED" && SED=sed

+test -z "$OBJDUMP" && OBJDUMP=objdump

+test -z "$RANLIB" && RANLIB=:

+test -z "$STRIP" && STRIP=:

+test -z "$ac_objext" && ac_objext=o

+

+# Determine commands to create old-style static archives.

+old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs'

+old_postinstall_cmds='chmod 644 $oldlib'

+old_postuninstall_cmds=

+

+if test -n "$RANLIB"; then

+  case $host_os in

+  openbsd*)

+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$oldlib"

+    ;;

+  *)

+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$oldlib"

+    ;;

+  esac

+  old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"

+fi

+

+_LT_CC_BASENAME([$compiler])

+

+# Only perform the check for file, if the check method requires it

+case $deplibs_check_method in

+file_magic*)

+  if test "$file_magic_cmd" = '$MAGIC_CMD'; then

+    AC_PATH_MAGIC

+  fi

+  ;;

+esac

+

+AC_PROVIDE_IFELSE([AC_LIBTOOL_DLOPEN], enable_dlopen=yes, enable_dlopen=no)

+AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL],

+enable_win32_dll=yes, enable_win32_dll=no)

+

+AC_ARG_ENABLE([libtool-lock],

+    [AC_HELP_STRING([--disable-libtool-lock],

+	[avoid locking (might break parallel builds)])])

+test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes

+

+AC_ARG_WITH([pic],

+    [AC_HELP_STRING([--with-pic],

+	[try to use only PIC/non-PIC objects @<:@default=use both@:>@])],

+    [pic_mode="$withval"],

+    [pic_mode=default])

+test -z "$pic_mode" && pic_mode=default

+

+# Use C for the default configuration in the libtool script

+tagname=

+AC_LIBTOOL_LANG_C_CONFIG

+_LT_AC_TAGCONFIG

+])# AC_LIBTOOL_SETUP

+

+

+# _LT_AC_SYS_COMPILER

+# -------------------

+AC_DEFUN([_LT_AC_SYS_COMPILER],

+[AC_REQUIRE([AC_PROG_CC])dnl

+

+# If no C compiler was specified, use CC.

+LTCC=${LTCC-"$CC"}

+

+# If no C compiler flags were specified, use CFLAGS.

+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}

+

+# Allow CC to be a program name with arguments.

+compiler=$CC

+])# _LT_AC_SYS_COMPILER

+

+

+# _LT_CC_BASENAME(CC)

+# -------------------

+# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.

+AC_DEFUN([_LT_CC_BASENAME],

+[for cc_temp in $1""; do

+  case $cc_temp in

+    compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;;

+    distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;;

+    \-*) ;;

+    *) break;;

+  esac

+done

+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`

+])

+

+

+# _LT_COMPILER_BOILERPLATE

+# ------------------------

+# Check for compiler boilerplate output or warnings with

+# the simple compiler test code.

+AC_DEFUN([_LT_COMPILER_BOILERPLATE],

+[ac_outfile=conftest.$ac_objext

+printf "$lt_simple_compile_test_code" >conftest.$ac_ext

+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err

+_lt_compiler_boilerplate=`cat conftest.err`

+$rm conftest*

+])# _LT_COMPILER_BOILERPLATE

+

+

+# _LT_LINKER_BOILERPLATE

+# ----------------------

+# Check for linker boilerplate output or warnings with

+# the simple link test code.

+AC_DEFUN([_LT_LINKER_BOILERPLATE],

+[ac_outfile=conftest.$ac_objext

+printf "$lt_simple_link_test_code" >conftest.$ac_ext

+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err

+_lt_linker_boilerplate=`cat conftest.err`

+$rm conftest*

+])# _LT_LINKER_BOILERPLATE

+

+

+# _LT_AC_SYS_LIBPATH_AIX

+# ----------------------

+# Links a minimal program and checks the executable

+# for the system default hardcoded library path. In most cases,

+# this is /usr/lib:/lib, but when the MPI compilers are used

+# the location of the communication and MPI libs are included too.

+# If we don't find anything, use the default library path according

+# to the aix ld manual.

+AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX],

+[AC_LINK_IFELSE(AC_LANG_PROGRAM,[

+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`

+# Check for a 64-bit object if we didn't find anything.

+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`; fi],[])

+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi

+])# _LT_AC_SYS_LIBPATH_AIX

+

+

+# _LT_AC_SHELL_INIT(ARG)

+# ----------------------

+AC_DEFUN([_LT_AC_SHELL_INIT],

+[ifdef([AC_DIVERSION_NOTICE],

+	     [AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)],

+	 [AC_DIVERT_PUSH(NOTICE)])

+$1

+AC_DIVERT_POP

+])# _LT_AC_SHELL_INIT

+

+

+# _LT_AC_PROG_ECHO_BACKSLASH

+# --------------------------

+# Add some code to the start of the generated configure script which

+# will find an echo command which doesn't interpret backslashes.

+AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH],

+[_LT_AC_SHELL_INIT([

+# Check that we are running under the correct shell.

+SHELL=${CONFIG_SHELL-/bin/sh}

+

+case X$ECHO in

+X*--fallback-echo)

+  # Remove one level of quotation (which was required for Make).

+  ECHO=`echo "$ECHO" | sed 's,\\\\\[$]\\[$]0,'[$]0','`

+  ;;

+esac

+

+echo=${ECHO-echo}

+if test "X[$]1" = X--no-reexec; then

+  # Discard the --no-reexec flag, and continue.

+  shift

+elif test "X[$]1" = X--fallback-echo; then

+  # Avoid inline document here, it may be left over

+  :

+elif test "X`($echo '\t') 2>/dev/null`" = 'X\t' ; then

+  # Yippee, $echo works!

+  :

+else

+  # Restart under the correct shell.

+  exec $SHELL "[$]0" --no-reexec ${1+"[$]@"}

+fi

+

+if test "X[$]1" = X--fallback-echo; then

+  # used as fallback echo

+  shift

+  cat <<EOF

+[$]*

+EOF

+  exit 0

+fi

+

+# The HP-UX ksh and POSIX shell print the target directory to stdout

+# if CDPATH is set.

+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

+

+if test -z "$ECHO"; then

+if test "X${echo_test_string+set}" != Xset; then

+# find a string as large as possible, as long as the shell can cope with it

+  for cmd in 'sed 50q "[$]0"' 'sed 20q "[$]0"' 'sed 10q "[$]0"' 'sed 2q "[$]0"' 'echo test'; do

+    # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...

+    if (echo_test_string=`eval $cmd`) 2>/dev/null &&

+       echo_test_string=`eval $cmd` &&

+       (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null

+    then

+      break

+    fi

+  done

+fi

+

+if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&

+   echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&

+   test "X$echo_testing_string" = "X$echo_test_string"; then

+  :

+else

+  # The Solaris, AIX, and Digital Unix default echo programs unquote

+  # backslashes.  This makes it impossible to quote backslashes using

+  #   echo "$something" | sed 's/\\/\\\\/g'

+  #

+  # So, first we look for a working echo in the user's PATH.

+

+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

+  for dir in $PATH /usr/ucb; do

+    IFS="$lt_save_ifs"

+    if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&

+       test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&

+       echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&

+       test "X$echo_testing_string" = "X$echo_test_string"; then

+      echo="$dir/echo"

+      break

+    fi

+  done

+  IFS="$lt_save_ifs"

+

+  if test "X$echo" = Xecho; then

+    # We didn't find a better echo, so look for alternatives.

+    if test "X`(print -r '\t') 2>/dev/null`" = 'X\t' &&

+       echo_testing_string=`(print -r "$echo_test_string") 2>/dev/null` &&

+       test "X$echo_testing_string" = "X$echo_test_string"; then

+      # This shell has a builtin print -r that does the trick.

+      echo='print -r'

+    elif (test -f /bin/ksh || test -f /bin/ksh$ac_exeext) &&

+	 test "X$CONFIG_SHELL" != X/bin/ksh; then

+      # If we have ksh, try running configure again with it.

+      ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}

+      export ORIGINAL_CONFIG_SHELL

+      CONFIG_SHELL=/bin/ksh

+      export CONFIG_SHELL

+      exec $CONFIG_SHELL "[$]0" --no-reexec ${1+"[$]@"}

+    else

+      # Try using printf.

+      echo='printf %s\n'

+      if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&

+	 echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&

+	 test "X$echo_testing_string" = "X$echo_test_string"; then

+	# Cool, printf works

+	:

+      elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&

+	   test "X$echo_testing_string" = 'X\t' &&

+	   echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&

+	   test "X$echo_testing_string" = "X$echo_test_string"; then

+	CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL

+	export CONFIG_SHELL

+	SHELL="$CONFIG_SHELL"

+	export SHELL

+	echo="$CONFIG_SHELL [$]0 --fallback-echo"

+      elif echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&

+	   test "X$echo_testing_string" = 'X\t' &&

+	   echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&

+	   test "X$echo_testing_string" = "X$echo_test_string"; then

+	echo="$CONFIG_SHELL [$]0 --fallback-echo"

+      else

+	# maybe with a smaller string...

+	prev=:

+

+	for cmd in 'echo test' 'sed 2q "[$]0"' 'sed 10q "[$]0"' 'sed 20q "[$]0"' 'sed 50q "[$]0"'; do

+	  if (test "X$echo_test_string" = "X`eval $cmd`") 2>/dev/null

+	  then

+	    break

+	  fi

+	  prev="$cmd"

+	done

+

+	if test "$prev" != 'sed 50q "[$]0"'; then

+	  echo_test_string=`eval $prev`

+	  export echo_test_string

+	  exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "[$]0" ${1+"[$]@"}

+	else

+	  # Oops.  We lost completely, so just stick with echo.

+	  echo=echo

+	fi

+      fi

+    fi

+  fi

+fi

+fi

+

+# Copy echo and quote the copy suitably for passing to libtool from

+# the Makefile, instead of quoting the original, which is used later.

+ECHO=$echo

+if test "X$ECHO" = "X$CONFIG_SHELL [$]0 --fallback-echo"; then

+   ECHO="$CONFIG_SHELL \\\$\[$]0 --fallback-echo"

+fi

+

+AC_SUBST(ECHO)

+])])# _LT_AC_PROG_ECHO_BACKSLASH

+

+

+# _LT_AC_LOCK

+# -----------

+AC_DEFUN([_LT_AC_LOCK],

+[AC_ARG_ENABLE([libtool-lock],

+    [AC_HELP_STRING([--disable-libtool-lock],

+	[avoid locking (might break parallel builds)])])

+test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes

+

+# Some flags need to be propagated to the compiler or linker for good

+# libtool support.

+case $host in

+ia64-*-hpux*)

+  # Find out which ABI we are using.

+  echo 'int i;' > conftest.$ac_ext

+  if AC_TRY_EVAL(ac_compile); then

+    case `/usr/bin/file conftest.$ac_objext` in

+    *ELF-32*)

+      HPUX_IA64_MODE="32"

+      ;;

+    *ELF-64*)

+      HPUX_IA64_MODE="64"

+      ;;

+    esac

+  fi

+  rm -rf conftest*

+  ;;

+*-*-irix6*)

+  # Find out which ABI we are using.

+  echo '[#]line __oline__ "configure"' > conftest.$ac_ext

+  if AC_TRY_EVAL(ac_compile); then

+   if test "$lt_cv_prog_gnu_ld" = yes; then

+    case `/usr/bin/file conftest.$ac_objext` in

+    *32-bit*)

+      LD="${LD-ld} -melf32bsmip"

+      ;;

+    *N32*)

+      LD="${LD-ld} -melf32bmipn32"

+      ;;

+    *64-bit*)

+      LD="${LD-ld} -melf64bmip"

+      ;;

+    esac

+   else

+    case `/usr/bin/file conftest.$ac_objext` in

+    *32-bit*)

+      LD="${LD-ld} -32"

+      ;;

+    *N32*)

+      LD="${LD-ld} -n32"

+      ;;

+    *64-bit*)

+      LD="${LD-ld} -64"

+      ;;

+    esac

+   fi

+  fi

+  rm -rf conftest*

+  ;;

+

+x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)

+  # Find out which ABI we are using.

+  echo 'int i;' > conftest.$ac_ext

+  if AC_TRY_EVAL(ac_compile); then

+    case `/usr/bin/file conftest.o` in

+    *32-bit*)

+      case $host in

+        x86_64-*linux*)

+          LD="${LD-ld} -m elf_i386"

+          ;;

+        ppc64-*linux*|powerpc64-*linux*)

+          LD="${LD-ld} -m elf32ppclinux"

+          ;;

+        s390x-*linux*)

+          LD="${LD-ld} -m elf_s390"

+          ;;

+        sparc64-*linux*)

+          LD="${LD-ld} -m elf32_sparc"

+          ;;

+      esac

+      ;;

+    *64-bit*)

+      case $host in

+        x86_64-*linux*)

+          LD="${LD-ld} -m elf_x86_64"

+          ;;

+        ppc*-*linux*|powerpc*-*linux*)

+          LD="${LD-ld} -m elf64ppc"

+          ;;

+        s390*-*linux*)

+          LD="${LD-ld} -m elf64_s390"

+          ;;

+        sparc*-*linux*)

+          LD="${LD-ld} -m elf64_sparc"

+          ;;

+      esac

+      ;;

+    esac

+  fi

+  rm -rf conftest*

+  ;;

+

+*-*-sco3.2v5*)

+  # On SCO OpenServer 5, we need -belf to get full-featured binaries.

+  SAVE_CFLAGS="$CFLAGS"

+  CFLAGS="$CFLAGS -belf"

+  AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,

+    [AC_LANG_PUSH(C)

+     AC_TRY_LINK([],[],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])

+     AC_LANG_POP])

+  if test x"$lt_cv_cc_needs_belf" != x"yes"; then

+    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf

+    CFLAGS="$SAVE_CFLAGS"

+  fi

+  ;;

+sparc*-*solaris*)

+  # Find out which ABI we are using.

+  echo 'int i;' > conftest.$ac_ext

+  if AC_TRY_EVAL(ac_compile); then

+    case `/usr/bin/file conftest.o` in

+    *64-bit*)

+      case $lt_cv_prog_gnu_ld in

+      yes*) LD="${LD-ld} -m elf64_sparc" ;;

+      *)    LD="${LD-ld} -64" ;;

+      esac

+      ;;

+    esac

+  fi

+  rm -rf conftest*

+  ;;

+

+AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL],

+[*-*-cygwin* | *-*-mingw* | *-*-pw32*)

+  AC_CHECK_TOOL(DLLTOOL, dlltool, false)

+  AC_CHECK_TOOL(AS, as, false)

+  AC_CHECK_TOOL(OBJDUMP, objdump, false)

+  ;;

+  ])

+esac

+

+need_locks="$enable_libtool_lock"

+

+])# _LT_AC_LOCK

+

+

+# AC_LIBTOOL_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,

+#		[OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE])

+# ----------------------------------------------------------------

+# Check whether the given compiler option works

+AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION],

+[AC_REQUIRE([LT_AC_PROG_SED])

+AC_CACHE_CHECK([$1], [$2],

+  [$2=no

+  ifelse([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4])

+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext

+   lt_compiler_flag="$3"

+   # Insert the option either (1) after the last *FLAGS variable, or

+   # (2) before a word containing "conftest.", or (3) at the end.

+   # Note that $ac_compile itself does not contain backslashes and begins

+   # with a dollar sign (not a hyphen), so the echo should work correctly.

+   # The option is referenced via a variable to avoid confusing sed.

+   lt_compile=`echo "$ac_compile" | $SED \

+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \

+   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \

+   -e 's:$: $lt_compiler_flag:'`

+   (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)

+   (eval "$lt_compile" 2>conftest.err)

+   ac_status=$?

+   cat conftest.err >&AS_MESSAGE_LOG_FD

+   echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD

+   if (exit $ac_status) && test -s "$ac_outfile"; then

+     # The compiler can only warn and ignore the option if not recognized

+     # So say no if there are warnings other than the usual output.

+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp

+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then

+       $2=yes

+     fi

+   fi

+   $rm conftest*

+])

+

+if test x"[$]$2" = xyes; then

+    ifelse([$5], , :, [$5])

+else

+    ifelse([$6], , :, [$6])

+fi

+])# AC_LIBTOOL_COMPILER_OPTION

+

+

+# AC_LIBTOOL_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,

+#                          [ACTION-SUCCESS], [ACTION-FAILURE])

+# ------------------------------------------------------------

+# Check whether the given compiler option works

+AC_DEFUN([AC_LIBTOOL_LINKER_OPTION],

+[AC_CACHE_CHECK([$1], [$2],

+  [$2=no

+   save_LDFLAGS="$LDFLAGS"

+   LDFLAGS="$LDFLAGS $3"

+   printf "$lt_simple_link_test_code" > conftest.$ac_ext

+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then

+     # The linker can only warn and ignore the option if not recognized

+     # So say no if there are warnings

+     if test -s conftest.err; then

+       # Append any errors to the config.log.

+       cat conftest.err 1>&AS_MESSAGE_LOG_FD

+       $echo "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp

+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

+       if diff conftest.exp conftest.er2 >/dev/null; then

+         $2=yes

+       fi

+     else

+       $2=yes

+     fi

+   fi

+   $rm conftest*

+   LDFLAGS="$save_LDFLAGS"

+])

+

+if test x"[$]$2" = xyes; then

+    ifelse([$4], , :, [$4])

+else

+    ifelse([$5], , :, [$5])

+fi

+])# AC_LIBTOOL_LINKER_OPTION

+

+

+# AC_LIBTOOL_SYS_MAX_CMD_LEN

+# --------------------------

+AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN],

+[# find the maximum length of command line arguments

+AC_MSG_CHECKING([the maximum length of command line arguments])

+AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl

+  i=0

+  teststring="ABCD"

+

+  case $build_os in

+  msdosdjgpp*)

+    # On DJGPP, this test can blow up pretty badly due to problems in libc

+    # (any single argument exceeding 2000 bytes causes a buffer overrun

+    # during glob expansion).  Even if it were fixed, the result of this

+    # check would be larger than it should be.

+    lt_cv_sys_max_cmd_len=12288;    # 12K is about right

+    ;;

+

+  gnu*)

+    # Under GNU Hurd, this test is not required because there is

+    # no limit to the length of command line arguments.

+    # Libtool will interpret -1 as no limit whatsoever

+    lt_cv_sys_max_cmd_len=-1;

+    ;;

+

+  cygwin* | mingw*)

+    # On Win9x/ME, this test blows up -- it succeeds, but takes

+    # about 5 minutes as the teststring grows exponentially.

+    # Worse, since 9x/ME are not pre-emptively multitasking,

+    # you end up with a "frozen" computer, even though with patience

+    # the test eventually succeeds (with a max line length of 256k).

+    # Instead, let's just punt: use the minimum linelength reported by

+    # all of the supported platforms: 8192 (on NT/2K/XP).

+    lt_cv_sys_max_cmd_len=8192;

+    ;;

+

+  amigaos*)

+    # On AmigaOS with pdksh, this test takes hours, literally.

+    # So we just punt and use a minimum line length of 8192.

+    lt_cv_sys_max_cmd_len=8192;

+    ;;

+

+  netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)

+    # This has been around since 386BSD, at least.  Likely further.

+    if test -x /sbin/sysctl; then

+      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`

+    elif test -x /usr/sbin/sysctl; then

+      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`

+    else

+      lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs

+    fi

+    # And add a safety zone

+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`

+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`

+    ;;

+

+  interix*)

+    # We know the value 262144 and hardcode it with a safety zone (like BSD)

+    lt_cv_sys_max_cmd_len=196608

+    ;;

+

+  osf*)

+    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure

+    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not

+    # nice to cause kernel panics so lets avoid the loop below.

+    # First set a reasonable default.

+    lt_cv_sys_max_cmd_len=16384

+    #

+    if test -x /sbin/sysconfig; then

+      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in

+        *1*) lt_cv_sys_max_cmd_len=-1 ;;

+      esac

+    fi

+    ;;

+  sco3.2v5*)

+    lt_cv_sys_max_cmd_len=102400

+    ;;

+  sysv5* | sco5v6* | sysv4.2uw2*)

+    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`

+    if test -n "$kargmax"; then

+      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[[ 	]]//'`

+    else

+      lt_cv_sys_max_cmd_len=32768

+    fi

+    ;;

+  *)

+    # If test is not a shell built-in, we'll probably end up computing a

+    # maximum length that is only half of the actual maximum length, but

+    # we can't tell.

+    SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}

+    while (test "X"`$SHELL [$]0 --fallback-echo "X$teststring" 2>/dev/null` \

+	       = "XX$teststring") >/dev/null 2>&1 &&

+	    new_result=`expr "X$teststring" : ".*" 2>&1` &&

+	    lt_cv_sys_max_cmd_len=$new_result &&

+	    test $i != 17 # 1/2 MB should be enough

+    do

+      i=`expr $i + 1`

+      teststring=$teststring$teststring

+    done

+    teststring=

+    # Add a significant safety factor because C++ compilers can tack on massive

+    # amounts of additional arguments before passing them to the linker.

+    # It appears as though 1/2 is a usable value.

+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`

+    ;;

+  esac

+])

+if test -n $lt_cv_sys_max_cmd_len ; then

+  AC_MSG_RESULT($lt_cv_sys_max_cmd_len)

+else

+  AC_MSG_RESULT(none)

+fi

+])# AC_LIBTOOL_SYS_MAX_CMD_LEN

+

+

+# _LT_AC_CHECK_DLFCN

+# ------------------

+AC_DEFUN([_LT_AC_CHECK_DLFCN],

+[AC_CHECK_HEADERS(dlfcn.h)dnl

+])# _LT_AC_CHECK_DLFCN

+

+

+# _LT_AC_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,

+#                           ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)

+# ---------------------------------------------------------------------

+AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF],

+[AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl

+if test "$cross_compiling" = yes; then :

+  [$4]

+else

+  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2

+  lt_status=$lt_dlunknown

+  cat > conftest.$ac_ext <<EOF

+[#line __oline__ "configure"

+#include "confdefs.h"

+

+#if HAVE_DLFCN_H

+#include <dlfcn.h>

+#endif

+

+#include <stdio.h>

+

+#ifdef RTLD_GLOBAL

+#  define LT_DLGLOBAL		RTLD_GLOBAL

+#else

+#  ifdef DL_GLOBAL

+#    define LT_DLGLOBAL		DL_GLOBAL

+#  else

+#    define LT_DLGLOBAL		0

+#  endif

+#endif

+

+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we

+   find out it does not work in some platform. */

+#ifndef LT_DLLAZY_OR_NOW

+#  ifdef RTLD_LAZY

+#    define LT_DLLAZY_OR_NOW		RTLD_LAZY

+#  else

+#    ifdef DL_LAZY

+#      define LT_DLLAZY_OR_NOW		DL_LAZY

+#    else

+#      ifdef RTLD_NOW

+#        define LT_DLLAZY_OR_NOW	RTLD_NOW

+#      else

+#        ifdef DL_NOW

+#          define LT_DLLAZY_OR_NOW	DL_NOW

+#        else

+#          define LT_DLLAZY_OR_NOW	0

+#        endif

+#      endif

+#    endif

+#  endif

+#endif

+

+#ifdef __cplusplus

+extern "C" void exit (int);

+#endif

+

+void fnord() { int i=42;}

+int main ()

+{

+  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);

+  int status = $lt_dlunknown;

+

+  if (self)

+    {

+      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;

+      else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;

+      /* dlclose (self); */

+    }

+  else

+    puts (dlerror ());

+

+    exit (status);

+}]

+EOF

+  if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then

+    (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null

+    lt_status=$?

+    case x$lt_status in

+      x$lt_dlno_uscore) $1 ;;

+      x$lt_dlneed_uscore) $2 ;;

+      x$lt_dlunknown|x*) $3 ;;

+    esac

+  else :

+    # compilation failed

+    $3

+  fi

+fi

+rm -fr conftest*

+])# _LT_AC_TRY_DLOPEN_SELF

+

+

+# AC_LIBTOOL_DLOPEN_SELF

+# ----------------------

+AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF],

+[AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl

+if test "x$enable_dlopen" != xyes; then

+  enable_dlopen=unknown

+  enable_dlopen_self=unknown

+  enable_dlopen_self_static=unknown

+else

+  lt_cv_dlopen=no

+  lt_cv_dlopen_libs=

+

+  case $host_os in

+  beos*)

+    lt_cv_dlopen="load_add_on"

+    lt_cv_dlopen_libs=

+    lt_cv_dlopen_self=yes

+    ;;

+

+  mingw* | pw32*)

+    lt_cv_dlopen="LoadLibrary"

+    lt_cv_dlopen_libs=

+   ;;

+

+  cygwin*)

+    lt_cv_dlopen="dlopen"

+    lt_cv_dlopen_libs=

+   ;;

+

+  darwin*)

+  # if libdl is installed we need to link against it

+    AC_CHECK_LIB([dl], [dlopen],

+		[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[

+    lt_cv_dlopen="dyld"

+    lt_cv_dlopen_libs=

+    lt_cv_dlopen_self=yes

+    ])

+   ;;

+

+  *)

+    AC_CHECK_FUNC([shl_load],

+	  [lt_cv_dlopen="shl_load"],

+      [AC_CHECK_LIB([dld], [shl_load],

+	    [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld"],

+	[AC_CHECK_FUNC([dlopen],

+	      [lt_cv_dlopen="dlopen"],

+	  [AC_CHECK_LIB([dl], [dlopen],

+		[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],

+	    [AC_CHECK_LIB([svld], [dlopen],

+		  [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"],

+	      [AC_CHECK_LIB([dld], [dld_link],

+		    [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"])

+	      ])

+	    ])

+	  ])

+	])

+      ])

+    ;;

+  esac

+

+  if test "x$lt_cv_dlopen" != xno; then

+    enable_dlopen=yes

+  else

+    enable_dlopen=no

+  fi

+

+  case $lt_cv_dlopen in

+  dlopen)

+    save_CPPFLAGS="$CPPFLAGS"

+    test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"

+

+    save_LDFLAGS="$LDFLAGS"

+    wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"

+

+    save_LIBS="$LIBS"

+    LIBS="$lt_cv_dlopen_libs $LIBS"

+

+    AC_CACHE_CHECK([whether a program can dlopen itself],

+	  lt_cv_dlopen_self, [dnl

+	  _LT_AC_TRY_DLOPEN_SELF(

+	    lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes,

+	    lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross)

+    ])

+

+    if test "x$lt_cv_dlopen_self" = xyes; then

+      wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"

+      AC_CACHE_CHECK([whether a statically linked program can dlopen itself],

+    	  lt_cv_dlopen_self_static, [dnl

+	  _LT_AC_TRY_DLOPEN_SELF(

+	    lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes,

+	    lt_cv_dlopen_self_static=no,  lt_cv_dlopen_self_static=cross)

+      ])

+    fi

+

+    CPPFLAGS="$save_CPPFLAGS"

+    LDFLAGS="$save_LDFLAGS"

+    LIBS="$save_LIBS"

+    ;;

+  esac

+

+  case $lt_cv_dlopen_self in

+  yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;

+  *) enable_dlopen_self=unknown ;;

+  esac

+

+  case $lt_cv_dlopen_self_static in

+  yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;

+  *) enable_dlopen_self_static=unknown ;;

+  esac

+fi

+])# AC_LIBTOOL_DLOPEN_SELF

+

+

+# AC_LIBTOOL_PROG_CC_C_O([TAGNAME])

+# ---------------------------------

+# Check to see if options -c and -o are simultaneously supported by compiler

+AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O],

+[AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl

+AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext],

+  [_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)],

+  [_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no

+   $rm -r conftest 2>/dev/null

+   mkdir conftest

+   cd conftest

+   mkdir out

+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext

+

+   lt_compiler_flag="-o out/conftest2.$ac_objext"

+   # Insert the option either (1) after the last *FLAGS variable, or

+   # (2) before a word containing "conftest.", or (3) at the end.

+   # Note that $ac_compile itself does not contain backslashes and begins

+   # with a dollar sign (not a hyphen), so the echo should work correctly.

+   lt_compile=`echo "$ac_compile" | $SED \

+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \

+   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \

+   -e 's:$: $lt_compiler_flag:'`

+   (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)

+   (eval "$lt_compile" 2>out/conftest.err)

+   ac_status=$?

+   cat out/conftest.err >&AS_MESSAGE_LOG_FD

+   echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD

+   if (exit $ac_status) && test -s out/conftest2.$ac_objext

+   then

+     # The compiler can only warn and ignore the option if not recognized

+     # So say no if there are warnings

+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp

+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2

+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then

+       _LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes

+     fi

+   fi

+   chmod u+w . 2>&AS_MESSAGE_LOG_FD

+   $rm conftest*

+   # SGI C++ compiler will create directory out/ii_files/ for

+   # template instantiation

+   test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files

+   $rm out/* && rmdir out

+   cd ..

+   rmdir conftest

+   $rm conftest*

+])

+])# AC_LIBTOOL_PROG_CC_C_O

+

+

+# AC_LIBTOOL_SYS_HARD_LINK_LOCKS([TAGNAME])

+# -----------------------------------------

+# Check to see if we can do hard links to lock some files if needed

+AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS],

+[AC_REQUIRE([_LT_AC_LOCK])dnl

+

+hard_links="nottested"

+if test "$_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != no; then

+  # do not overwrite the value of need_locks provided by the user

+  AC_MSG_CHECKING([if we can lock with hard links])

+  hard_links=yes

+  $rm conftest*

+  ln conftest.a conftest.b 2>/dev/null && hard_links=no

+  touch conftest.a

+  ln conftest.a conftest.b 2>&5 || hard_links=no

+  ln conftest.a conftest.b 2>/dev/null && hard_links=no

+  AC_MSG_RESULT([$hard_links])

+  if test "$hard_links" = no; then

+    AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe])

+    need_locks=warn

+  fi

+else

+  need_locks=no

+fi

+])# AC_LIBTOOL_SYS_HARD_LINK_LOCKS

+

+

+# AC_LIBTOOL_OBJDIR

+# -----------------

+AC_DEFUN([AC_LIBTOOL_OBJDIR],

+[AC_CACHE_CHECK([for objdir], [lt_cv_objdir],

+[rm -f .libs 2>/dev/null

+mkdir .libs 2>/dev/null

+if test -d .libs; then

+  lt_cv_objdir=.libs

+else

+  # MS-DOS does not allow filenames that begin with a dot.

+  lt_cv_objdir=_libs

+fi

+rmdir .libs 2>/dev/null])

+objdir=$lt_cv_objdir

+])# AC_LIBTOOL_OBJDIR

+

+

+# AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH([TAGNAME])

+# ----------------------------------------------

+# Check hardcoding attributes.

+AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH],

+[AC_MSG_CHECKING([how to hardcode library paths into programs])

+_LT_AC_TAGVAR(hardcode_action, $1)=

+if test -n "$_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)" || \

+   test -n "$_LT_AC_TAGVAR(runpath_var, $1)" || \

+   test "X$_LT_AC_TAGVAR(hardcode_automatic, $1)" = "Xyes" ; then

+

+  # We can hardcode non-existant directories.

+  if test "$_LT_AC_TAGVAR(hardcode_direct, $1)" != no &&

+     # If the only mechanism to avoid hardcoding is shlibpath_var, we

+     # have to relink, otherwise we might link with an installed library

+     # when we should be linking with a yet-to-be-installed one

+     ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)" != no &&

+     test "$_LT_AC_TAGVAR(hardcode_minus_L, $1)" != no; then

+    # Linking always hardcodes the temporary library directory.

+    _LT_AC_TAGVAR(hardcode_action, $1)=relink

+  else

+    # We can link without hardcoding, and we can hardcode nonexisting dirs.

+    _LT_AC_TAGVAR(hardcode_action, $1)=immediate

+  fi

+else

+  # We cannot hardcode anything, or else we can only hardcode existing

+  # directories.

+  _LT_AC_TAGVAR(hardcode_action, $1)=unsupported

+fi

+AC_MSG_RESULT([$_LT_AC_TAGVAR(hardcode_action, $1)])

+

+if test "$_LT_AC_TAGVAR(hardcode_action, $1)" = relink; then

+  # Fast installation is not supported

+  enable_fast_install=no

+elif test "$shlibpath_overrides_runpath" = yes ||

+     test "$enable_shared" = no; then

+  # Fast installation is not necessary

+  enable_fast_install=needless

+fi

+])# AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH

+

+

+# AC_LIBTOOL_SYS_LIB_STRIP

+# ------------------------

+AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP],

+[striplib=

+old_striplib=

+AC_MSG_CHECKING([whether stripping libraries is possible])

+if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then

+  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"

+  test -z "$striplib" && striplib="$STRIP --strip-unneeded"

+  AC_MSG_RESULT([yes])

+else

+# FIXME - insert some real tests, host_os isn't really good enough

+  case $host_os in

+   darwin*)

+       if test -n "$STRIP" ; then

+         striplib="$STRIP -x"

+         AC_MSG_RESULT([yes])

+       else

+  AC_MSG_RESULT([no])

+fi

+       ;;

+   *)

+  AC_MSG_RESULT([no])

+    ;;

+  esac

+fi

+])# AC_LIBTOOL_SYS_LIB_STRIP

+

+

+# AC_LIBTOOL_SYS_DYNAMIC_LINKER

+# -----------------------------

+# PORTME Fill in your ld.so characteristics

+AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER],

+[AC_MSG_CHECKING([dynamic linker characteristics])

+library_names_spec=

+libname_spec='lib$name'

+soname_spec=

+shrext_cmds=".so"

+postinstall_cmds=

+postuninstall_cmds=

+finish_cmds=

+finish_eval=

+shlibpath_var=

+shlibpath_overrides_runpath=unknown

+version_type=none

+dynamic_linker="$host_os ld.so"

+sys_lib_dlsearch_path_spec="/lib /usr/lib"

+if test "$GCC" = yes; then

+  sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`

+  if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then

+    # if the path contains ";" then we assume it to be the separator

+    # otherwise default to the standard path separator (i.e. ":") - it is

+    # assumed that no part of a normal pathname contains ";" but that should

+    # okay in the real world where ";" in dirpaths is itself problematic.

+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`

+  else

+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`

+  fi

+else

+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"

+fi

+need_lib_prefix=unknown

+hardcode_into_libs=no

+

+# when you set need_version to no, make sure it does not cause -set_version

+# flags to be left without arguments

+need_version=unknown

+

+case $host_os in

+aix3*)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'

+  shlibpath_var=LIBPATH

+

+  # AIX 3 has no versioning support, so we append a major version to the name.

+  soname_spec='${libname}${release}${shared_ext}$major'

+  ;;

+

+aix4* | aix5*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  hardcode_into_libs=yes

+  if test "$host_cpu" = ia64; then

+    # AIX 5 supports IA64

+    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'

+    shlibpath_var=LD_LIBRARY_PATH

+  else

+    # With GCC up to 2.95.x, collect2 would create an import file

+    # for dependence libraries.  The import file would start with

+    # the line `#! .'.  This would cause the generated library to

+    # depend on `.', always an invalid library.  This was fixed in

+    # development snapshots of GCC prior to 3.0.

+    case $host_os in

+      aix4 | aix4.[[01]] | aix4.[[01]].*)

+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'

+	   echo ' yes '

+	   echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then

+	:

+      else

+	can_build_shared=no

+      fi

+      ;;

+    esac

+    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct

+    # soname into executable. Probably we can add versioning support to

+    # collect2, so additional links can be useful in future.

+    if test "$aix_use_runtimelinking" = yes; then

+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so

+      # instead of lib<name>.a to let people know that these are not

+      # typical AIX shared libraries.

+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+    else

+      # We preserve .a as extension for shared libraries through AIX4.2

+      # and later when we are not doing run time linking.

+      library_names_spec='${libname}${release}.a $libname.a'

+      soname_spec='${libname}${release}${shared_ext}$major'

+    fi

+    shlibpath_var=LIBPATH

+  fi

+  ;;

+

+amigaos*)

+  library_names_spec='$libname.ixlibrary $libname.a'

+  # Create ${libname}_ixlibrary.a entries in /sys/libs.

+  finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'

+  ;;

+

+beos*)

+  library_names_spec='${libname}${shared_ext}'

+  dynamic_linker="$host_os ld.so"

+  shlibpath_var=LIBRARY_PATH

+  ;;

+

+bsdi[[45]]*)

+  version_type=linux

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"

+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"

+  # the default ld.so.conf also contains /usr/contrib/lib and

+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow

+  # libtool to hard-code these into programs

+  ;;

+

+cygwin* | mingw* | pw32*)

+  version_type=windows

+  shrext_cmds=".dll"

+  need_version=no

+  need_lib_prefix=no

+

+  case $GCC,$host_os in

+  yes,cygwin* | yes,mingw* | yes,pw32*)

+    library_names_spec='$libname.dll.a'

+    # DLL is installed to $(libdir)/../bin by postinstall_cmds

+    postinstall_cmds='base_file=`basename \${file}`~

+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~

+      dldir=$destdir/`dirname \$dlpath`~

+      test -d \$dldir || mkdir -p \$dldir~

+      $install_prog $dir/$dlname \$dldir/$dlname~

+      chmod a+x \$dldir/$dlname'

+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~

+      dlpath=$dir/\$dldll~

+       $rm \$dlpath'

+    shlibpath_overrides_runpath=yes

+

+    case $host_os in

+    cygwin*)

+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'

+      soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'

+      sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"

+      ;;

+    mingw*)

+      # MinGW DLLs use traditional 'lib' prefix

+      soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'

+      sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`

+      if echo "$sys_lib_search_path_spec" | [grep ';[c-zC-Z]:/' >/dev/null]; then

+        # It is most probably a Windows format PATH printed by

+        # mingw gcc, but we are running on Cygwin. Gcc prints its search

+        # path with ; separators, and with drive letters. We can handle the

+        # drive letters (cygwin fileutils understands them), so leave them,

+        # especially as we might pass files found there to a mingw objdump,

+        # which wouldn't understand a cygwinified path. Ahh.

+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`

+      else

+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`

+      fi

+      ;;

+    pw32*)

+      # pw32 DLLs use 'pw' prefix rather than 'lib'

+      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'

+      ;;

+    esac

+    ;;

+

+  *)

+    library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib'

+    ;;

+  esac

+  dynamic_linker='Win32 ld.exe'

+  # FIXME: first we should search . and the directory the executable is in

+  shlibpath_var=PATH

+  ;;

+

+darwin* | rhapsody*)

+  dynamic_linker="$host_os dyld"

+  version_type=darwin

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext'

+  soname_spec='${libname}${release}${major}$shared_ext'

+  shlibpath_overrides_runpath=yes

+  shlibpath_var=DYLD_LIBRARY_PATH

+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'

+  # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same.

+  if test "$GCC" = yes; then

+    sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"`

+  else

+    sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib'

+  fi

+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'

+  ;;

+

+dgux*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  ;;

+

+freebsd1*)

+  dynamic_linker=no

+  ;;

+

+kfreebsd*-gnu)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  dynamic_linker='GNU ld.so'

+  ;;

+

+freebsd* | dragonfly*)

+  # DragonFly does not have aout.  When/if they implement a new

+  # versioning mechanism, adjust this.

+  if test -x /usr/bin/objformat; then

+    objformat=`/usr/bin/objformat`

+  else

+    case $host_os in

+    freebsd[[123]]*) objformat=aout ;;

+    *) objformat=elf ;;

+    esac

+  fi

+  version_type=freebsd-$objformat

+  case $version_type in

+    freebsd-elf*)

+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'

+      need_version=no

+      need_lib_prefix=no

+      ;;

+    freebsd-*)

+      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'

+      need_version=yes

+      ;;

+  esac

+  shlibpath_var=LD_LIBRARY_PATH

+  case $host_os in

+  freebsd2*)

+    shlibpath_overrides_runpath=yes

+    ;;

+  freebsd3.[[01]]* | freebsdelf3.[[01]]*)

+    shlibpath_overrides_runpath=yes

+    hardcode_into_libs=yes

+    ;;

+  freebsd3.[[2-9]]* | freebsdelf3.[[2-9]]* | \

+  freebsd4.[[0-5]] | freebsdelf4.[[0-5]] | freebsd4.1.1 | freebsdelf4.1.1)

+    shlibpath_overrides_runpath=no

+    hardcode_into_libs=yes

+    ;;

+  freebsd*) # from 4.6 on

+    shlibpath_overrides_runpath=yes

+    hardcode_into_libs=yes

+    ;;

+  esac

+  ;;

+

+gnu*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  hardcode_into_libs=yes

+  ;;

+

+hpux9* | hpux10* | hpux11*)

+  # Give a soname corresponding to the major version so that dld.sl refuses to

+  # link against other versions.

+  version_type=sunos

+  need_lib_prefix=no

+  need_version=no

+  case $host_cpu in

+  ia64*)

+    shrext_cmds='.so'

+    hardcode_into_libs=yes

+    dynamic_linker="$host_os dld.so"

+    shlibpath_var=LD_LIBRARY_PATH

+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+    soname_spec='${libname}${release}${shared_ext}$major'

+    if test "X$HPUX_IA64_MODE" = X32; then

+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"

+    else

+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"

+    fi

+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec

+    ;;

+   hppa*64*)

+     shrext_cmds='.sl'

+     hardcode_into_libs=yes

+     dynamic_linker="$host_os dld.sl"

+     shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH

+     shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.

+     library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+     soname_spec='${libname}${release}${shared_ext}$major'

+     sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"

+     sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec

+     ;;

+   *)

+    shrext_cmds='.sl'

+    dynamic_linker="$host_os dld.sl"

+    shlibpath_var=SHLIB_PATH

+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+    soname_spec='${libname}${release}${shared_ext}$major'

+    ;;

+  esac

+  # HP-UX runs *really* slowly unless shared libraries are mode 555.

+  postinstall_cmds='chmod 555 $lib'

+  ;;

+

+interix3*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  ;;

+

+irix5* | irix6* | nonstopux*)

+  case $host_os in

+    nonstopux*) version_type=nonstopux ;;

+    *)

+	if test "$lt_cv_prog_gnu_ld" = yes; then

+		version_type=linux

+	else

+		version_type=irix

+	fi ;;

+  esac

+  need_lib_prefix=no

+  need_version=no

+  soname_spec='${libname}${release}${shared_ext}$major'

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'

+  case $host_os in

+  irix5* | nonstopux*)

+    libsuff= shlibsuff=

+    ;;

+  *)

+    case $LD in # libtool.m4 will add one of these switches to LD

+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")

+      libsuff= shlibsuff= libmagic=32-bit;;

+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")

+      libsuff=32 shlibsuff=N32 libmagic=N32;;

+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")

+      libsuff=64 shlibsuff=64 libmagic=64-bit;;

+    *) libsuff= shlibsuff= libmagic=never-match;;

+    esac

+    ;;

+  esac

+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH

+  shlibpath_overrides_runpath=no

+  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"

+  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"

+  hardcode_into_libs=yes

+  ;;

+

+# No shared lib support for Linux oldld, aout, or coff.

+linux*oldld* | linux*aout* | linux*coff*)

+  dynamic_linker=no

+  ;;

+

+# This must be Linux ELF.

+linux*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  # This implies no fast_install, which is unacceptable.

+  # Some rework will be needed to allow for fast_install

+  # before this can be enabled.

+  hardcode_into_libs=yes

+

+  # Append ld.so.conf contents to the search path

+  if test -f /etc/ld.so.conf; then

+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;/^$/d' | tr '\n' ' '`

+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"

+  fi

+

+  # We used to test for /lib/ld.so.1 and disable shared libraries on

+  # powerpc, because MkLinux only supported shared libraries with the

+  # GNU dynamic linker.  Since this was broken with cross compilers,

+  # most powerpc-linux boxes support dynamic linking these days and

+  # people can always --disable-shared, the test was removed, and we

+  # assume the GNU/Linux dynamic linker is in use.

+  dynamic_linker='GNU/Linux ld.so'

+  ;;

+

+netbsdelf*-gnu)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  dynamic_linker='NetBSD ld.elf_so'

+  ;;

+

+knetbsd*-gnu)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  dynamic_linker='GNU ld.so'

+  ;;

+

+netbsd*)

+  version_type=sunos

+  need_lib_prefix=no

+  need_version=no

+  if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'

+    dynamic_linker='NetBSD (a.out) ld.so'

+  else

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+    soname_spec='${libname}${release}${shared_ext}$major'

+    dynamic_linker='NetBSD ld.elf_so'

+  fi

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  hardcode_into_libs=yes

+  ;;

+

+newsos6)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  ;;

+

+nto-qnx*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  ;;

+

+openbsd*)

+  version_type=sunos

+  sys_lib_dlsearch_path_spec="/usr/lib"

+  need_lib_prefix=no

+  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.

+  case $host_os in

+    openbsd3.3 | openbsd3.3.*) need_version=yes ;;

+    *)                         need_version=no  ;;

+  esac

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

+    case $host_os in

+      openbsd2.[[89]] | openbsd2.[[89]].*)

+	shlibpath_overrides_runpath=no

+	;;

+      *)

+	shlibpath_overrides_runpath=yes

+	;;

+      esac

+  else

+    shlibpath_overrides_runpath=yes

+  fi

+  ;;

+

+os2*)

+  libname_spec='$name'

+  shrext_cmds=".dll"

+  need_lib_prefix=no

+  library_names_spec='$libname${shared_ext} $libname.a'

+  dynamic_linker='OS/2 ld.exe'

+  shlibpath_var=LIBPATH

+  ;;

+

+osf3* | osf4* | osf5*)

+  version_type=osf

+  need_lib_prefix=no

+  need_version=no

+  soname_spec='${libname}${release}${shared_ext}$major'

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  shlibpath_var=LD_LIBRARY_PATH

+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"

+  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"

+  ;;

+

+solaris*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  hardcode_into_libs=yes

+  # ldd complains unless libraries are executable

+  postinstall_cmds='chmod +x $lib'

+  ;;

+

+sunos4*)

+  version_type=sunos

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  if test "$with_gnu_ld" = yes; then

+    need_lib_prefix=no

+  fi

+  need_version=yes

+  ;;

+

+sysv4 | sysv4.3*)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  case $host_vendor in

+    sni)

+      shlibpath_overrides_runpath=no

+      need_lib_prefix=no

+      export_dynamic_flag_spec='${wl}-Blargedynsym'

+      runpath_var=LD_RUN_PATH

+      ;;

+    siemens)

+      need_lib_prefix=no

+      ;;

+    motorola)

+      need_lib_prefix=no

+      need_version=no

+      shlibpath_overrides_runpath=no

+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'

+      ;;

+  esac

+  ;;

+

+sysv4*MP*)

+  if test -d /usr/nec ;then

+    version_type=linux

+    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'

+    soname_spec='$libname${shared_ext}.$major'

+    shlibpath_var=LD_LIBRARY_PATH

+  fi

+  ;;

+

+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)

+  version_type=freebsd-elf

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  hardcode_into_libs=yes

+  if test "$with_gnu_ld" = yes; then

+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'

+    shlibpath_overrides_runpath=no

+  else

+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'

+    shlibpath_overrides_runpath=yes

+    case $host_os in

+      sco3.2v5*)

+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"

+	;;

+    esac

+  fi

+  sys_lib_dlsearch_path_spec='/usr/lib'

+  ;;

+

+uts4*)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  ;;

+

+*)

+  dynamic_linker=no

+  ;;

+esac

+AC_MSG_RESULT([$dynamic_linker])

+test "$dynamic_linker" = no && can_build_shared=no

+

+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"

+if test "$GCC" = yes; then

+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"

+fi

+])# AC_LIBTOOL_SYS_DYNAMIC_LINKER

+

+

+# _LT_AC_TAGCONFIG

+# ----------------

+AC_DEFUN([_LT_AC_TAGCONFIG],

+[AC_ARG_WITH([tags],

+    [AC_HELP_STRING([--with-tags@<:@=TAGS@:>@],

+        [include additional configurations @<:@automatic@:>@])],

+    [tagnames="$withval"])

+

+if test -f "$ltmain" && test -n "$tagnames"; then

+  if test ! -f "${ofile}"; then

+    AC_MSG_WARN([output file `$ofile' does not exist])

+  fi

+

+  if test -z "$LTCC"; then

+    eval "`$SHELL ${ofile} --config | grep '^LTCC='`"

+    if test -z "$LTCC"; then

+      AC_MSG_WARN([output file `$ofile' does not look like a libtool script])

+    else

+      AC_MSG_WARN([using `LTCC=$LTCC', extracted from `$ofile'])

+    fi

+  fi

+  if test -z "$LTCFLAGS"; then

+    eval "`$SHELL ${ofile} --config | grep '^LTCFLAGS='`"

+  fi

+

+  # Extract list of available tagged configurations in $ofile.

+  # Note that this assumes the entire list is on one line.

+  available_tags=`grep "^available_tags=" "${ofile}" | $SED -e 's/available_tags=\(.*$\)/\1/' -e 's/\"//g'`

+

+  lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"

+  for tagname in $tagnames; do

+    IFS="$lt_save_ifs"

+    # Check whether tagname contains only valid characters

+    case `$echo "X$tagname" | $Xsed -e 's:[[-_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890,/]]::g'` in

+    "") ;;

+    *)  AC_MSG_ERROR([invalid tag name: $tagname])

+	;;

+    esac

+

+    if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "${ofile}" > /dev/null

+    then

+      AC_MSG_ERROR([tag name \"$tagname\" already exists])

+    fi

+

+    # Update the list of available tags.

+    if test -n "$tagname"; then

+      echo appending configuration tag \"$tagname\" to $ofile

+

+      case $tagname in

+      CXX)

+	if test -n "$CXX" && ( test "X$CXX" != "Xno" &&

+	    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||

+	    (test "X$CXX" != "Xg++"))) ; then

+	  AC_LIBTOOL_LANG_CXX_CONFIG

+	else

+	  tagname=""

+	fi

+	;;

+

+      F77)

+	if test -n "$F77" && test "X$F77" != "Xno"; then

+	  AC_LIBTOOL_LANG_F77_CONFIG

+	else

+	  tagname=""

+	fi

+	;;

+

+      GCJ)

+	if test -n "$GCJ" && test "X$GCJ" != "Xno"; then

+	  AC_LIBTOOL_LANG_GCJ_CONFIG

+	else

+	  tagname=""

+	fi

+	;;

+

+      RC)

+	AC_LIBTOOL_LANG_RC_CONFIG

+	;;

+

+      *)

+	AC_MSG_ERROR([Unsupported tag name: $tagname])

+	;;

+      esac

+

+      # Append the new tag name to the list of available tags.

+      if test -n "$tagname" ; then

+      available_tags="$available_tags $tagname"

+    fi

+    fi

+  done

+  IFS="$lt_save_ifs"

+

+  # Now substitute the updated list of available tags.

+  if eval "sed -e 's/^available_tags=.*\$/available_tags=\"$available_tags\"/' \"$ofile\" > \"${ofile}T\""; then

+    mv "${ofile}T" "$ofile"

+    chmod +x "$ofile"

+  else

+    rm -f "${ofile}T"

+    AC_MSG_ERROR([unable to update list of available tagged configurations.])

+  fi

+fi

+])# _LT_AC_TAGCONFIG

+

+

+# AC_LIBTOOL_DLOPEN

+# -----------------

+# enable checks for dlopen support

+AC_DEFUN([AC_LIBTOOL_DLOPEN],

+ [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])

+])# AC_LIBTOOL_DLOPEN

+

+

+# AC_LIBTOOL_WIN32_DLL

+# --------------------

+# declare package support for building win32 DLLs

+AC_DEFUN([AC_LIBTOOL_WIN32_DLL],

+[AC_BEFORE([$0], [AC_LIBTOOL_SETUP])

+])# AC_LIBTOOL_WIN32_DLL

+

+

+# AC_ENABLE_SHARED([DEFAULT])

+# ---------------------------

+# implement the --enable-shared flag

+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.

+AC_DEFUN([AC_ENABLE_SHARED],

+[define([AC_ENABLE_SHARED_DEFAULT], ifelse($1, no, no, yes))dnl

+AC_ARG_ENABLE([shared],

+    [AC_HELP_STRING([--enable-shared@<:@=PKGS@:>@],

+	[build shared libraries @<:@default=]AC_ENABLE_SHARED_DEFAULT[@:>@])],

+    [p=${PACKAGE-default}

+    case $enableval in

+    yes) enable_shared=yes ;;

+    no) enable_shared=no ;;

+    *)

+      enable_shared=no

+      # Look at the argument we got.  We use all the common list separators.

+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"

+      for pkg in $enableval; do

+	IFS="$lt_save_ifs"

+	if test "X$pkg" = "X$p"; then

+	  enable_shared=yes

+	fi

+      done

+      IFS="$lt_save_ifs"

+      ;;

+    esac],

+    [enable_shared=]AC_ENABLE_SHARED_DEFAULT)

+])# AC_ENABLE_SHARED

+

+

+# AC_DISABLE_SHARED

+# -----------------

+# set the default shared flag to --disable-shared

+AC_DEFUN([AC_DISABLE_SHARED],

+[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl

+AC_ENABLE_SHARED(no)

+])# AC_DISABLE_SHARED

+

+

+# AC_ENABLE_STATIC([DEFAULT])

+# ---------------------------

+# implement the --enable-static flag

+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.

+AC_DEFUN([AC_ENABLE_STATIC],

+[define([AC_ENABLE_STATIC_DEFAULT], ifelse($1, no, no, yes))dnl

+AC_ARG_ENABLE([static],

+    [AC_HELP_STRING([--enable-static@<:@=PKGS@:>@],

+	[build static libraries @<:@default=]AC_ENABLE_STATIC_DEFAULT[@:>@])],

+    [p=${PACKAGE-default}

+    case $enableval in

+    yes) enable_static=yes ;;

+    no) enable_static=no ;;

+    *)

+     enable_static=no

+      # Look at the argument we got.  We use all the common list separators.

+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"

+      for pkg in $enableval; do

+	IFS="$lt_save_ifs"

+	if test "X$pkg" = "X$p"; then

+	  enable_static=yes

+	fi

+      done

+      IFS="$lt_save_ifs"

+      ;;

+    esac],

+    [enable_static=]AC_ENABLE_STATIC_DEFAULT)

+])# AC_ENABLE_STATIC

+

+

+# AC_DISABLE_STATIC

+# -----------------

+# set the default static flag to --disable-static

+AC_DEFUN([AC_DISABLE_STATIC],

+[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl

+AC_ENABLE_STATIC(no)

+])# AC_DISABLE_STATIC

+

+

+# AC_ENABLE_FAST_INSTALL([DEFAULT])

+# ---------------------------------

+# implement the --enable-fast-install flag

+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.

+AC_DEFUN([AC_ENABLE_FAST_INSTALL],

+[define([AC_ENABLE_FAST_INSTALL_DEFAULT], ifelse($1, no, no, yes))dnl

+AC_ARG_ENABLE([fast-install],

+    [AC_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],

+    [optimize for fast installation @<:@default=]AC_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],

+    [p=${PACKAGE-default}

+    case $enableval in

+    yes) enable_fast_install=yes ;;

+    no) enable_fast_install=no ;;

+    *)

+      enable_fast_install=no

+      # Look at the argument we got.  We use all the common list separators.

+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"

+      for pkg in $enableval; do

+	IFS="$lt_save_ifs"

+	if test "X$pkg" = "X$p"; then

+	  enable_fast_install=yes

+	fi

+      done

+      IFS="$lt_save_ifs"

+      ;;

+    esac],

+    [enable_fast_install=]AC_ENABLE_FAST_INSTALL_DEFAULT)

+])# AC_ENABLE_FAST_INSTALL

+

+

+# AC_DISABLE_FAST_INSTALL

+# -----------------------

+# set the default to --disable-fast-install

+AC_DEFUN([AC_DISABLE_FAST_INSTALL],

+[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl

+AC_ENABLE_FAST_INSTALL(no)

+])# AC_DISABLE_FAST_INSTALL

+

+

+# AC_LIBTOOL_PICMODE([MODE])

+# --------------------------

+# implement the --with-pic flag

+# MODE is either `yes' or `no'.  If omitted, it defaults to `both'.

+AC_DEFUN([AC_LIBTOOL_PICMODE],

+[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl

+pic_mode=ifelse($#,1,$1,default)

+])# AC_LIBTOOL_PICMODE

+

+

+# AC_PROG_EGREP

+# -------------

+# This is predefined starting with Autoconf 2.54, so this conditional

+# definition can be removed once we require Autoconf 2.54 or later.

+m4_ifndef([AC_PROG_EGREP], [AC_DEFUN([AC_PROG_EGREP],

+[AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],

+   [if echo a | (grep -E '(a|b)') >/dev/null 2>&1

+    then ac_cv_prog_egrep='grep -E'

+    else ac_cv_prog_egrep='egrep'

+    fi])

+ EGREP=$ac_cv_prog_egrep

+ AC_SUBST([EGREP])

+])])

+

+

+# AC_PATH_TOOL_PREFIX

+# -------------------

+# find a file program which can recognise shared library

+AC_DEFUN([AC_PATH_TOOL_PREFIX],

+[AC_REQUIRE([AC_PROG_EGREP])dnl

+AC_MSG_CHECKING([for $1])

+AC_CACHE_VAL(lt_cv_path_MAGIC_CMD,

+[case $MAGIC_CMD in

+[[\\/*] |  ?:[\\/]*])

+  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.

+  ;;

+*)

+  lt_save_MAGIC_CMD="$MAGIC_CMD"

+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

+dnl $ac_dummy forces splitting on constant user-supplied paths.

+dnl POSIX.2 word splitting is done only on the output of word expansions,

+dnl not every word.  This closes a longstanding sh security hole.

+  ac_dummy="ifelse([$2], , $PATH, [$2])"

+  for ac_dir in $ac_dummy; do

+    IFS="$lt_save_ifs"

+    test -z "$ac_dir" && ac_dir=.

+    if test -f $ac_dir/$1; then

+      lt_cv_path_MAGIC_CMD="$ac_dir/$1"

+      if test -n "$file_magic_test_file"; then

+	case $deplibs_check_method in

+	"file_magic "*)

+	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`

+	  MAGIC_CMD="$lt_cv_path_MAGIC_CMD"

+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |

+	    $EGREP "$file_magic_regex" > /dev/null; then

+	    :

+	  else

+	    cat <<EOF 1>&2

+

+*** Warning: the command libtool uses to detect shared libraries,

+*** $file_magic_cmd, produces output that libtool cannot recognize.

+*** The result is that libtool may fail to recognize shared libraries

+*** as such.  This will affect the creation of libtool libraries that

+*** depend on shared libraries, but programs linked with such libtool

+*** libraries will work regardless of this problem.  Nevertheless, you

+*** may want to report the problem to your system manager and/or to

+*** bug-libtool@gnu.org

+

+EOF

+	  fi ;;

+	esac

+      fi

+      break

+    fi

+  done

+  IFS="$lt_save_ifs"

+  MAGIC_CMD="$lt_save_MAGIC_CMD"

+  ;;

+esac])

+MAGIC_CMD="$lt_cv_path_MAGIC_CMD"

+if test -n "$MAGIC_CMD"; then

+  AC_MSG_RESULT($MAGIC_CMD)

+else

+  AC_MSG_RESULT(no)

+fi

+])# AC_PATH_TOOL_PREFIX

+

+

+# AC_PATH_MAGIC

+# -------------

+# find a file program which can recognise a shared library

+AC_DEFUN([AC_PATH_MAGIC],

+[AC_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH)

+if test -z "$lt_cv_path_MAGIC_CMD"; then

+  if test -n "$ac_tool_prefix"; then

+    AC_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH)

+  else

+    MAGIC_CMD=:

+  fi

+fi

+])# AC_PATH_MAGIC

+

+

+# AC_PROG_LD

+# ----------

+# find the pathname to the GNU or non-GNU linker

+AC_DEFUN([AC_PROG_LD],

+[AC_ARG_WITH([gnu-ld],

+    [AC_HELP_STRING([--with-gnu-ld],

+	[assume the C compiler uses GNU ld @<:@default=no@:>@])],

+    [test "$withval" = no || with_gnu_ld=yes],

+    [with_gnu_ld=no])

+AC_REQUIRE([LT_AC_PROG_SED])dnl

+AC_REQUIRE([AC_PROG_CC])dnl

+AC_REQUIRE([AC_CANONICAL_HOST])dnl

+AC_REQUIRE([AC_CANONICAL_BUILD])dnl

+ac_prog=ld

+if test "$GCC" = yes; then

+  # Check if gcc -print-prog-name=ld gives a path.

+  AC_MSG_CHECKING([for ld used by $CC])

+  case $host in

+  *-*-mingw*)

+    # gcc leaves a trailing carriage return which upsets mingw

+    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;

+  *)

+    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;

+  esac

+  case $ac_prog in

+    # Accept absolute paths.

+    [[\\/]]* | ?:[[\\/]]*)

+      re_direlt='/[[^/]][[^/]]*/\.\./'

+      # Canonicalize the pathname of ld

+      ac_prog=`echo $ac_prog| $SED 's%\\\\%/%g'`

+      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do

+	ac_prog=`echo $ac_prog| $SED "s%$re_direlt%/%"`

+      done

+      test -z "$LD" && LD="$ac_prog"

+      ;;

+  "")

+    # If it fails, then pretend we aren't using GCC.

+    ac_prog=ld

+    ;;

+  *)

+    # If it is relative, then search for the first ld in PATH.

+    with_gnu_ld=unknown

+    ;;

+  esac

+elif test "$with_gnu_ld" = yes; then

+  AC_MSG_CHECKING([for GNU ld])

+else

+  AC_MSG_CHECKING([for non-GNU ld])

+fi

+AC_CACHE_VAL(lt_cv_path_LD,

+[if test -z "$LD"; then

+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

+  for ac_dir in $PATH; do

+    IFS="$lt_save_ifs"

+    test -z "$ac_dir" && ac_dir=.

+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then

+      lt_cv_path_LD="$ac_dir/$ac_prog"

+      # Check to see if the program is GNU ld.  I'd rather use --version,

+      # but apparently some variants of GNU ld only accept -v.

+      # Break only if it was the GNU/non-GNU ld that we prefer.

+      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in

+      *GNU* | *'with BFD'*)

+	test "$with_gnu_ld" != no && break

+	;;

+      *)

+	test "$with_gnu_ld" != yes && break

+	;;

+      esac

+    fi

+  done

+  IFS="$lt_save_ifs"

+else

+  lt_cv_path_LD="$LD" # Let the user override the test with a path.

+fi])

+LD="$lt_cv_path_LD"

+if test -n "$LD"; then

+  AC_MSG_RESULT($LD)

+else

+  AC_MSG_RESULT(no)

+fi

+test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])

+AC_PROG_LD_GNU

+])# AC_PROG_LD

+

+

+# AC_PROG_LD_GNU

+# --------------

+AC_DEFUN([AC_PROG_LD_GNU],

+[AC_REQUIRE([AC_PROG_EGREP])dnl

+AC_CACHE_CHECK([if the linker ($LD) is GNU ld], lt_cv_prog_gnu_ld,

+[# I'd rather use --version here, but apparently some GNU lds only accept -v.

+case `$LD -v 2>&1 </dev/null` in

+*GNU* | *'with BFD'*)

+  lt_cv_prog_gnu_ld=yes

+  ;;

+*)

+  lt_cv_prog_gnu_ld=no

+  ;;

+esac])

+with_gnu_ld=$lt_cv_prog_gnu_ld

+])# AC_PROG_LD_GNU

+

+

+# AC_PROG_LD_RELOAD_FLAG

+# ----------------------

+# find reload flag for linker

+#   -- PORTME Some linkers may need a different reload flag.

+AC_DEFUN([AC_PROG_LD_RELOAD_FLAG],

+[AC_CACHE_CHECK([for $LD option to reload object files],

+  lt_cv_ld_reload_flag,

+  [lt_cv_ld_reload_flag='-r'])

+reload_flag=$lt_cv_ld_reload_flag

+case $reload_flag in

+"" | " "*) ;;

+*) reload_flag=" $reload_flag" ;;

+esac

+reload_cmds='$LD$reload_flag -o $output$reload_objs'

+case $host_os in

+  darwin*)

+    if test "$GCC" = yes; then

+      reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'

+    else

+      reload_cmds='$LD$reload_flag -o $output$reload_objs'

+    fi

+    ;;

+esac

+])# AC_PROG_LD_RELOAD_FLAG

+

+

+# AC_DEPLIBS_CHECK_METHOD

+# -----------------------

+# how to check for library dependencies

+#  -- PORTME fill in with the dynamic library characteristics

+AC_DEFUN([AC_DEPLIBS_CHECK_METHOD],

+[AC_CACHE_CHECK([how to recognise dependent libraries],

+lt_cv_deplibs_check_method,

+[lt_cv_file_magic_cmd='$MAGIC_CMD'

+lt_cv_file_magic_test_file=

+lt_cv_deplibs_check_method='unknown'

+# Need to set the preceding variable on all platforms that support

+# interlibrary dependencies.

+# 'none' -- dependencies not supported.

+# `unknown' -- same as none, but documents that we really don't know.

+# 'pass_all' -- all dependencies passed with no checks.

+# 'test_compile' -- check by making test program.

+# 'file_magic [[regex]]' -- check by looking for files in library path

+# which responds to the $file_magic_cmd with a given extended regex.

+# If you have `file' or equivalent on your system and you're not sure

+# whether `pass_all' will *always* work, you probably want this one.

+

+case $host_os in

+aix4* | aix5*)

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+

+beos*)

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+

+bsdi[[45]]*)

+  lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib)'

+  lt_cv_file_magic_cmd='/usr/bin/file -L'

+  lt_cv_file_magic_test_file=/shlib/libc.so

+  ;;

+

+cygwin*)

+  # func_win32_libid is a shell function defined in ltmain.sh

+  lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'

+  lt_cv_file_magic_cmd='func_win32_libid'

+  ;;

+

+mingw* | pw32*)

+  # Base MSYS/MinGW do not provide the 'file' command needed by

+  # func_win32_libid shell function, so use a weaker test based on 'objdump'.

+  lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'

+  lt_cv_file_magic_cmd='$OBJDUMP -f'

+  ;;

+

+darwin* | rhapsody*)

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+

+freebsd* | kfreebsd*-gnu | dragonfly*)

+  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then

+    case $host_cpu in

+    i*86 )

+      # Not sure whether the presence of OpenBSD here was a mistake.

+      # Let's accept both of them until this is cleared up.

+      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[[3-9]]86 (compact )?demand paged shared library'

+      lt_cv_file_magic_cmd=/usr/bin/file

+      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`

+      ;;

+    esac

+  else

+    lt_cv_deplibs_check_method=pass_all

+  fi

+  ;;

+

+gnu*)

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+

+hpux10.20* | hpux11*)

+  lt_cv_file_magic_cmd=/usr/bin/file

+  case $host_cpu in

+  ia64*)

+    lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64'

+    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so

+    ;;

+  hppa*64*)

+    [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - PA-RISC [0-9].[0-9]']

+    lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl

+    ;;

+  *)

+    lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]].[[0-9]]) shared library'

+    lt_cv_file_magic_test_file=/usr/lib/libc.sl

+    ;;

+  esac

+  ;;

+

+interix3*)

+  # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here

+  lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|\.a)$'

+  ;;

+

+irix5* | irix6* | nonstopux*)

+  case $LD in

+  *-32|*"-32 ") libmagic=32-bit;;

+  *-n32|*"-n32 ") libmagic=N32;;

+  *-64|*"-64 ") libmagic=64-bit;;

+  *) libmagic=never-match;;

+  esac

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+

+# This must be Linux ELF.

+linux*)

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+

+netbsd* | netbsdelf*-gnu | knetbsd*-gnu)

+  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then

+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'

+  else

+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$'

+  fi

+  ;;

+

+newos6*)

+  lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)'

+  lt_cv_file_magic_cmd=/usr/bin/file

+  lt_cv_file_magic_test_file=/usr/lib/libnls.so

+  ;;

+

+nto-qnx*)

+  lt_cv_deplibs_check_method=unknown

+  ;;

+

+openbsd*)

+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$'

+  else

+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'

+  fi

+  ;;

+

+osf3* | osf4* | osf5*)

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+

+solaris*)

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+

+sysv4 | sysv4.3*)

+  case $host_vendor in

+  motorola)

+    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]'

+    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`

+    ;;

+  ncr)

+    lt_cv_deplibs_check_method=pass_all

+    ;;

+  sequent)

+    lt_cv_file_magic_cmd='/bin/file'

+    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )'

+    ;;

+  sni)

+    lt_cv_file_magic_cmd='/bin/file'

+    lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib"

+    lt_cv_file_magic_test_file=/lib/libc.so

+    ;;

+  siemens)

+    lt_cv_deplibs_check_method=pass_all

+    ;;

+  pc)

+    lt_cv_deplibs_check_method=pass_all

+    ;;

+  esac

+  ;;

+

+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+esac

+])

+file_magic_cmd=$lt_cv_file_magic_cmd

+deplibs_check_method=$lt_cv_deplibs_check_method

+test -z "$deplibs_check_method" && deplibs_check_method=unknown

+])# AC_DEPLIBS_CHECK_METHOD

+

+

+# AC_PROG_NM

+# ----------

+# find the pathname to a BSD-compatible name lister

+AC_DEFUN([AC_PROG_NM],

+[AC_CACHE_CHECK([for BSD-compatible nm], lt_cv_path_NM,

+[if test -n "$NM"; then

+  # Let the user override the test.

+  lt_cv_path_NM="$NM"

+else

+  lt_nm_to_check="${ac_tool_prefix}nm"

+  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then 

+    lt_nm_to_check="$lt_nm_to_check nm"

+  fi

+  for lt_tmp_nm in $lt_nm_to_check; do

+    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

+    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do

+      IFS="$lt_save_ifs"

+      test -z "$ac_dir" && ac_dir=.

+      tmp_nm="$ac_dir/$lt_tmp_nm"

+      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then

+	# Check to see if the nm accepts a BSD-compat flag.

+	# Adding the `sed 1q' prevents false positives on HP-UX, which says:

+	#   nm: unknown option "B" ignored

+	# Tru64's nm complains that /dev/null is an invalid object file

+	case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in

+	*/dev/null* | *'Invalid file or object type'*)

+	  lt_cv_path_NM="$tmp_nm -B"

+	  break

+	  ;;

+	*)

+	  case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in

+	  */dev/null*)

+	    lt_cv_path_NM="$tmp_nm -p"

+	    break

+	    ;;

+	  *)

+	    lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but

+	    continue # so that we can try to find one that supports BSD flags

+	    ;;

+	  esac

+	  ;;

+	esac

+      fi

+    done

+    IFS="$lt_save_ifs"

+  done

+  test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm

+fi])

+NM="$lt_cv_path_NM"

+])# AC_PROG_NM

+

+

+# AC_CHECK_LIBM

+# -------------

+# check for math library

+AC_DEFUN([AC_CHECK_LIBM],

+[AC_REQUIRE([AC_CANONICAL_HOST])dnl

+LIBM=

+case $host in

+*-*-beos* | *-*-cygwin* | *-*-pw32* | *-*-darwin*)

+  # These system don't have libm, or don't need it

+  ;;

+*-ncr-sysv4.3*)

+  AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw")

+  AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm")

+  ;;

+*)

+  AC_CHECK_LIB(m, cos, LIBM="-lm")

+  ;;

+esac

+])# AC_CHECK_LIBM

+

+

+# AC_LIBLTDL_CONVENIENCE([DIRECTORY])

+# -----------------------------------

+# sets LIBLTDL to the link flags for the libltdl convenience library and

+# LTDLINCL to the include flags for the libltdl header and adds

+# --enable-ltdl-convenience to the configure arguments.  Note that

+# AC_CONFIG_SUBDIRS is not called here.  If DIRECTORY is not provided,

+# it is assumed to be `libltdl'.  LIBLTDL will be prefixed with

+# '${top_builddir}/' and LTDLINCL will be prefixed with '${top_srcdir}/'

+# (note the single quotes!).  If your package is not flat and you're not

+# using automake, define top_builddir and top_srcdir appropriately in

+# the Makefiles.

+AC_DEFUN([AC_LIBLTDL_CONVENIENCE],

+[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl

+  case $enable_ltdl_convenience in

+  no) AC_MSG_ERROR([this package needs a convenience libltdl]) ;;

+  "") enable_ltdl_convenience=yes

+      ac_configure_args="$ac_configure_args --enable-ltdl-convenience" ;;

+  esac

+  LIBLTDL='${top_builddir}/'ifelse($#,1,[$1],['libltdl'])/libltdlc.la

+  LTDLINCL='-I${top_srcdir}/'ifelse($#,1,[$1],['libltdl'])

+  # For backwards non-gettext consistent compatibility...

+  INCLTDL="$LTDLINCL"

+])# AC_LIBLTDL_CONVENIENCE

+

+

+# AC_LIBLTDL_INSTALLABLE([DIRECTORY])

+# -----------------------------------

+# sets LIBLTDL to the link flags for the libltdl installable library and

+# LTDLINCL to the include flags for the libltdl header and adds

+# --enable-ltdl-install to the configure arguments.  Note that

+# AC_CONFIG_SUBDIRS is not called here.  If DIRECTORY is not provided,

+# and an installed libltdl is not found, it is assumed to be `libltdl'.

+# LIBLTDL will be prefixed with '${top_builddir}/'# and LTDLINCL with

+# '${top_srcdir}/' (note the single quotes!).  If your package is not

+# flat and you're not using automake, define top_builddir and top_srcdir

+# appropriately in the Makefiles.

+# In the future, this macro may have to be called after AC_PROG_LIBTOOL.

+AC_DEFUN([AC_LIBLTDL_INSTALLABLE],

+[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl

+  AC_CHECK_LIB(ltdl, lt_dlinit,

+  [test x"$enable_ltdl_install" != xyes && enable_ltdl_install=no],

+  [if test x"$enable_ltdl_install" = xno; then

+     AC_MSG_WARN([libltdl not installed, but installation disabled])

+   else

+     enable_ltdl_install=yes

+   fi

+  ])

+  if test x"$enable_ltdl_install" = x"yes"; then

+    ac_configure_args="$ac_configure_args --enable-ltdl-install"

+    LIBLTDL='${top_builddir}/'ifelse($#,1,[$1],['libltdl'])/libltdl.la

+    LTDLINCL='-I${top_srcdir}/'ifelse($#,1,[$1],['libltdl'])

+  else

+    ac_configure_args="$ac_configure_args --enable-ltdl-install=no"

+    LIBLTDL="-lltdl"

+    LTDLINCL=

+  fi

+  # For backwards non-gettext consistent compatibility...

+  INCLTDL="$LTDLINCL"

+])# AC_LIBLTDL_INSTALLABLE

+

+

+# AC_LIBTOOL_CXX

+# --------------

+# enable support for C++ libraries

+AC_DEFUN([AC_LIBTOOL_CXX],

+[AC_REQUIRE([_LT_AC_LANG_CXX])

+])# AC_LIBTOOL_CXX

+

+

+# _LT_AC_LANG_CXX

+# ---------------

+AC_DEFUN([_LT_AC_LANG_CXX],

+[AC_REQUIRE([AC_PROG_CXX])

+AC_REQUIRE([_LT_AC_PROG_CXXCPP])

+_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}CXX])

+])# _LT_AC_LANG_CXX

+

+# _LT_AC_PROG_CXXCPP

+# ------------------

+AC_DEFUN([_LT_AC_PROG_CXXCPP],

+[

+AC_REQUIRE([AC_PROG_CXX])

+if test -n "$CXX" && ( test "X$CXX" != "Xno" &&

+    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||

+    (test "X$CXX" != "Xg++"))) ; then

+  AC_PROG_CXXCPP

+fi

+])# _LT_AC_PROG_CXXCPP

+

+# AC_LIBTOOL_F77

+# --------------

+# enable support for Fortran 77 libraries

+AC_DEFUN([AC_LIBTOOL_F77],

+[AC_REQUIRE([_LT_AC_LANG_F77])

+])# AC_LIBTOOL_F77

+

+

+# _LT_AC_LANG_F77

+# ---------------

+AC_DEFUN([_LT_AC_LANG_F77],

+[AC_REQUIRE([AC_PROG_F77])

+_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}F77])

+])# _LT_AC_LANG_F77

+

+

+# AC_LIBTOOL_GCJ

+# --------------

+# enable support for GCJ libraries

+AC_DEFUN([AC_LIBTOOL_GCJ],

+[AC_REQUIRE([_LT_AC_LANG_GCJ])

+])# AC_LIBTOOL_GCJ

+

+

+# _LT_AC_LANG_GCJ

+# ---------------

+AC_DEFUN([_LT_AC_LANG_GCJ],

+[AC_PROVIDE_IFELSE([AC_PROG_GCJ],[],

+  [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],[],

+    [AC_PROVIDE_IFELSE([LT_AC_PROG_GCJ],[],

+      [ifdef([AC_PROG_GCJ],[AC_REQUIRE([AC_PROG_GCJ])],

+	 [ifdef([A][M_PROG_GCJ],[AC_REQUIRE([A][M_PROG_GCJ])],

+	   [AC_REQUIRE([A][C_PROG_GCJ_OR_A][M_PROG_GCJ])])])])])])

+_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}GCJ])

+])# _LT_AC_LANG_GCJ

+

+

+# AC_LIBTOOL_RC

+# -------------

+# enable support for Windows resource files

+AC_DEFUN([AC_LIBTOOL_RC],

+[AC_REQUIRE([LT_AC_PROG_RC])

+_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}RC])

+])# AC_LIBTOOL_RC

+

+

+# AC_LIBTOOL_LANG_C_CONFIG

+# ------------------------

+# Ensure that the configuration vars for the C compiler are

+# suitably defined.  Those variables are subsequently used by

+# AC_LIBTOOL_CONFIG to write the compiler configuration to `libtool'.

+AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG], [_LT_AC_LANG_C_CONFIG])

+AC_DEFUN([_LT_AC_LANG_C_CONFIG],

+[lt_save_CC="$CC"

+AC_LANG_PUSH(C)

+

+# Source file extension for C test sources.

+ac_ext=c

+

+# Object file extension for compiled C test sources.

+objext=o

+_LT_AC_TAGVAR(objext, $1)=$objext

+

+# Code to be used in simple compile tests

+lt_simple_compile_test_code="int some_variable = 0;\n"

+

+# Code to be used in simple link tests

+lt_simple_link_test_code='int main(){return(0);}\n'

+

+_LT_AC_SYS_COMPILER

+

+# save warnings/boilerplate of simple test code

+_LT_COMPILER_BOILERPLATE

+_LT_LINKER_BOILERPLATE

+

+AC_LIBTOOL_PROG_COMPILER_NO_RTTI($1)

+AC_LIBTOOL_PROG_COMPILER_PIC($1)

+AC_LIBTOOL_PROG_CC_C_O($1)

+AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)

+AC_LIBTOOL_PROG_LD_SHLIBS($1)

+AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)

+AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)

+AC_LIBTOOL_SYS_LIB_STRIP

+AC_LIBTOOL_DLOPEN_SELF

+

+# Report which library types will actually be built

+AC_MSG_CHECKING([if libtool supports shared libraries])

+AC_MSG_RESULT([$can_build_shared])

+

+AC_MSG_CHECKING([whether to build shared libraries])

+test "$can_build_shared" = "no" && enable_shared=no

+

+# On AIX, shared libraries and static libraries use the same namespace, and

+# are all built from PIC.

+case $host_os in

+aix3*)

+  test "$enable_shared" = yes && enable_static=no

+  if test -n "$RANLIB"; then

+    archive_cmds="$archive_cmds~\$RANLIB \$lib"

+    postinstall_cmds='$RANLIB $lib'

+  fi

+  ;;

+

+aix4* | aix5*)

+  if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then

+    test "$enable_shared" = yes && enable_static=no

+  fi

+    ;;

+esac

+AC_MSG_RESULT([$enable_shared])

+

+AC_MSG_CHECKING([whether to build static libraries])

+# Make sure either enable_shared or enable_static is yes.

+test "$enable_shared" = yes || enable_static=yes

+AC_MSG_RESULT([$enable_static])

+

+AC_LIBTOOL_CONFIG($1)

+

+AC_LANG_POP

+CC="$lt_save_CC"

+])# AC_LIBTOOL_LANG_C_CONFIG

+

+

+# AC_LIBTOOL_LANG_CXX_CONFIG

+# --------------------------

+# Ensure that the configuration vars for the C compiler are

+# suitably defined.  Those variables are subsequently used by

+# AC_LIBTOOL_CONFIG to write the compiler configuration to `libtool'.

+AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG], [_LT_AC_LANG_CXX_CONFIG(CXX)])

+AC_DEFUN([_LT_AC_LANG_CXX_CONFIG],

+[AC_LANG_PUSH(C++)

+AC_REQUIRE([AC_PROG_CXX])

+AC_REQUIRE([_LT_AC_PROG_CXXCPP])

+

+_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

+_LT_AC_TAGVAR(allow_undefined_flag, $1)=

+_LT_AC_TAGVAR(always_export_symbols, $1)=no

+_LT_AC_TAGVAR(archive_expsym_cmds, $1)=

+_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=

+_LT_AC_TAGVAR(hardcode_direct, $1)=no

+_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=

+_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=

+_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=

+_LT_AC_TAGVAR(hardcode_minus_L, $1)=no

+_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported

+_LT_AC_TAGVAR(hardcode_automatic, $1)=no

+_LT_AC_TAGVAR(module_cmds, $1)=

+_LT_AC_TAGVAR(module_expsym_cmds, $1)=

+_LT_AC_TAGVAR(link_all_deplibs, $1)=unknown

+_LT_AC_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds

+_LT_AC_TAGVAR(no_undefined_flag, $1)=

+_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=

+_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=no

+

+# Dependencies to place before and after the object being linked:

+_LT_AC_TAGVAR(predep_objects, $1)=

+_LT_AC_TAGVAR(postdep_objects, $1)=

+_LT_AC_TAGVAR(predeps, $1)=

+_LT_AC_TAGVAR(postdeps, $1)=

+_LT_AC_TAGVAR(compiler_lib_search_path, $1)=

+

+# Source file extension for C++ test sources.

+ac_ext=cpp

+

+# Object file extension for compiled C++ test sources.

+objext=o

+_LT_AC_TAGVAR(objext, $1)=$objext

+

+# Code to be used in simple compile tests

+lt_simple_compile_test_code="int some_variable = 0;\n"

+

+# Code to be used in simple link tests

+lt_simple_link_test_code='int main(int, char *[[]]) { return(0); }\n'

+

+# ltmain only uses $CC for tagged configurations so make sure $CC is set.

+_LT_AC_SYS_COMPILER

+

+# save warnings/boilerplate of simple test code

+_LT_COMPILER_BOILERPLATE

+_LT_LINKER_BOILERPLATE

+

+# Allow CC to be a program name with arguments.

+lt_save_CC=$CC

+lt_save_LD=$LD

+lt_save_GCC=$GCC

+GCC=$GXX

+lt_save_with_gnu_ld=$with_gnu_ld

+lt_save_path_LD=$lt_cv_path_LD

+if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then

+  lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx

+else

+  $as_unset lt_cv_prog_gnu_ld

+fi

+if test -n "${lt_cv_path_LDCXX+set}"; then

+  lt_cv_path_LD=$lt_cv_path_LDCXX

+else

+  $as_unset lt_cv_path_LD

+fi

+test -z "${LDCXX+set}" || LD=$LDCXX

+CC=${CXX-"c++"}

+compiler=$CC

+_LT_AC_TAGVAR(compiler, $1)=$CC

+_LT_CC_BASENAME([$compiler])

+

+# We don't want -fno-exception wen compiling C++ code, so set the

+# no_builtin_flag separately

+if test "$GXX" = yes; then

+  _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'

+else

+  _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=

+fi

+

+if test "$GXX" = yes; then

+  # Set up default GNU C++ configuration

+

+  AC_PROG_LD

+

+  # Check if GNU C++ uses GNU ld as the underlying linker, since the

+  # archiving commands below assume that GNU ld is being used.

+  if test "$with_gnu_ld" = yes; then

+    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'

+    _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+

+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'

+    _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'

+

+    # If archive_cmds runs LD, not CC, wlarc should be empty

+    # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to

+    #     investigate it a little bit more. (MM)

+    wlarc='${wl}'

+

+    # ancient GNU ld didn't support --whole-archive et. al.

+    if eval "`$CC -print-prog-name=ld` --help 2>&1" | \

+	grep 'no-whole-archive' > /dev/null; then

+      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'

+    else

+      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=

+    fi

+  else

+    with_gnu_ld=no

+    wlarc=

+

+    # A generic and very simple default shared library creation

+    # command for GNU C++ for the case where it uses the native

+    # linker, instead of GNU ld.  If possible, this setting should

+    # overridden to take advantage of the native linker features on

+    # the platform it is being used on.

+    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'

+  fi

+

+  # Commands to make compiler produce verbose output that lists

+  # what "hidden" libraries, object files and flags are used when

+  # linking a shared library.

+  output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"'

+

+else

+  GXX=no

+  with_gnu_ld=no

+  wlarc=

+fi

+

+# PORTME: fill in a description of your system's C++ link characteristics

+AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])

+_LT_AC_TAGVAR(ld_shlibs, $1)=yes

+case $host_os in

+  aix3*)

+    # FIXME: insert proper C++ library support

+    _LT_AC_TAGVAR(ld_shlibs, $1)=no

+    ;;

+  aix4* | aix5*)

+    if test "$host_cpu" = ia64; then

+      # On IA64, the linker does run time linking by default, so we don't

+      # have to do anything special.

+      aix_use_runtimelinking=no

+      exp_sym_flag='-Bexport'

+      no_entry_flag=""

+    else

+      aix_use_runtimelinking=no

+

+      # Test if we are trying to use run time linking or normal

+      # AIX style linking. If -brtl is somewhere in LDFLAGS, we

+      # need to do runtime linking.

+      case $host_os in aix4.[[23]]|aix4.[[23]].*|aix5*)

+	for ld_flag in $LDFLAGS; do

+	  case $ld_flag in

+	  *-brtl*)

+	    aix_use_runtimelinking=yes

+	    break

+	    ;;

+	  esac

+	done

+	;;

+      esac

+

+      exp_sym_flag='-bexport'

+      no_entry_flag='-bnoentry'

+    fi

+

+    # When large executables or shared objects are built, AIX ld can

+    # have problems creating the table of contents.  If linking a library

+    # or program results in "error TOC overflow" add -mminimal-toc to

+    # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not

+    # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.

+

+    _LT_AC_TAGVAR(archive_cmds, $1)=''

+    _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+    _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':'

+    _LT_AC_TAGVAR(link_all_deplibs, $1)=yes

+

+    if test "$GXX" = yes; then

+      case $host_os in aix4.[[012]]|aix4.[[012]].*)

+      # We only want to do this on AIX 4.2 and lower, the check

+      # below for broken collect2 doesn't work under 4.3+

+	collect2name=`${CC} -print-prog-name=collect2`

+	if test -f "$collect2name" && \

+	   strings "$collect2name" | grep resolve_lib_name >/dev/null

+	then

+	  # We have reworked collect2

+	  _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+	else

+	  # We have old collect2

+	  _LT_AC_TAGVAR(hardcode_direct, $1)=unsupported

+	  # It fails to find uninstalled libraries when the uninstalled

+	  # path is not listed in the libpath.  Setting hardcode_minus_L

+	  # to unsupported forces relinking

+	  _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

+	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

+	  _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=

+	fi

+	;;

+      esac

+      shared_flag='-shared'

+      if test "$aix_use_runtimelinking" = yes; then

+	shared_flag="$shared_flag "'${wl}-G'

+      fi

+    else

+      # not using gcc

+      if test "$host_cpu" = ia64; then

+	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release

+	# chokes on -Wl,-G. The following line is correct:

+	shared_flag='-G'

+      else

+	if test "$aix_use_runtimelinking" = yes; then

+	  shared_flag='${wl}-G'

+	else

+	  shared_flag='${wl}-bM:SRE'

+	fi

+      fi

+    fi

+

+    # It seems that -bexpall does not export symbols beginning with

+    # underscore (_), so it is better to generate a list of symbols to export.

+    _LT_AC_TAGVAR(always_export_symbols, $1)=yes

+    if test "$aix_use_runtimelinking" = yes; then

+      # Warning - without using the other runtime loading flags (-brtl),

+      # -berok will link without error, but may produce a broken library.

+      _LT_AC_TAGVAR(allow_undefined_flag, $1)='-berok'

+      # Determine the default libpath from the value encoded in an empty executable.

+      _LT_AC_SYS_LIBPATH_AIX

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"

+

+      _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"

+     else

+      if test "$host_cpu" = ia64; then

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'

+	_LT_AC_TAGVAR(allow_undefined_flag, $1)="-z nodefs"

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"

+      else

+	# Determine the default libpath from the value encoded in an empty executable.

+	_LT_AC_SYS_LIBPATH_AIX

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"

+	# Warning - without using the other run time loading flags,

+	# -berok will link without error, but may produce a broken library.

+	_LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'

+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'

+	# Exported symbols can be pulled into shared objects from archives

+	_LT_AC_TAGVAR(whole_archive_flag_spec, $1)='$convenience'

+	_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes

+	# This is similar to how AIX traditionally builds its shared libraries.

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'

+      fi

+    fi

+    ;;

+

+  beos*)

+    if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+      _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported

+      # Joseph Beckenbach <jrb3@best.com> says some releases of gcc

+      # support --undefined.  This deserves some investigation.  FIXME

+      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+    else

+      _LT_AC_TAGVAR(ld_shlibs, $1)=no

+    fi

+    ;;

+

+  chorus*)

+    case $cc_basename in

+      *)

+	# FIXME: insert proper C++ library support

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+	;;

+    esac

+    ;;

+

+  cygwin* | mingw* | pw32*)

+    # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,

+    # as there is no search path for DLLs.

+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

+    _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported

+    _LT_AC_TAGVAR(always_export_symbols, $1)=no

+    _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes

+

+    if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then

+      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'

+      # If the export-symbols file already is a .def file (1st line

+      # is EXPORTS), use it as is; otherwise, prepend...

+      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then

+	cp $export_symbols $output_objdir/$soname.def;

+      else

+	echo EXPORTS > $output_objdir/$soname.def;

+	cat $export_symbols >> $output_objdir/$soname.def;

+      fi~

+      $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'

+    else

+      _LT_AC_TAGVAR(ld_shlibs, $1)=no

+    fi

+  ;;

+      darwin* | rhapsody*)

+        case $host_os in

+        rhapsody* | darwin1.[[012]])

+         _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}suppress'

+         ;;

+       *) # Darwin 1.3 on

+         if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then

+           _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'

+         else

+           case ${MACOSX_DEPLOYMENT_TARGET} in

+             10.[[012]])

+               _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'

+               ;;

+             10.*)

+               _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}dynamic_lookup'

+               ;;

+           esac

+         fi

+         ;;

+        esac

+      _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

+      _LT_AC_TAGVAR(hardcode_direct, $1)=no

+      _LT_AC_TAGVAR(hardcode_automatic, $1)=yes

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported

+      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=''

+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes

+

+    if test "$GXX" = yes ; then

+      lt_int_apple_cc_single_mod=no

+      output_verbose_link_cmd='echo'

+      if $CC -dumpspecs 2>&1 | $EGREP 'single_module' >/dev/null ; then

+       lt_int_apple_cc_single_mod=yes

+      fi

+      if test "X$lt_int_apple_cc_single_mod" = Xyes ; then

+       _LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'

+      else

+          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -r -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring'

+        fi

+        _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'

+        # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds

+          if test "X$lt_int_apple_cc_single_mod" = Xyes ; then

+            _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+          else

+            _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+          fi

+            _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+      else

+      case $cc_basename in

+        xlc*)

+         output_verbose_link_cmd='echo'

+          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj ${wl}-single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'

+          _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'

+          # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds

+          _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj ${wl}-single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+          _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+          ;;

+       *)

+         _LT_AC_TAGVAR(ld_shlibs, $1)=no

+          ;;

+      esac

+      fi

+        ;;

+

+  dgux*)

+    case $cc_basename in

+      ec++*)

+	# FIXME: insert proper C++ library support

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+	;;

+      ghcx*)

+	# Green Hills C++ Compiler

+	# FIXME: insert proper C++ library support

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+	;;

+      *)

+	# FIXME: insert proper C++ library support

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+	;;

+    esac

+    ;;

+  freebsd[[12]]*)

+    # C++ shared libraries reported to be fairly broken before switch to ELF

+    _LT_AC_TAGVAR(ld_shlibs, $1)=no

+    ;;

+  freebsd-elf*)

+    _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

+    ;;

+  freebsd* | kfreebsd*-gnu | dragonfly*)

+    # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF

+    # conventions

+    _LT_AC_TAGVAR(ld_shlibs, $1)=yes

+    ;;

+  gnu*)

+    ;;

+  hpux9*)

+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'

+    _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

+    _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'

+    _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+    _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,

+				# but as the default

+				# location of the library.

+

+    case $cc_basename in

+    CC*)

+      # FIXME: insert proper C++ library support

+      _LT_AC_TAGVAR(ld_shlibs, $1)=no

+      ;;

+    aCC*)

+      _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

+      # Commands to make compiler produce verbose output that lists

+      # what "hidden" libraries, object files and flags are used when

+      # linking a shared library.

+      #

+      # There doesn't appear to be a way to prevent this compiler from

+      # explicitly linking system object files so we need to strip them

+      # from the output so that they don't get included in the library

+      # dependencies.

+      output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | grep "[[-]]L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

+      ;;

+    *)

+      if test "$GXX" = yes; then

+        _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -shared -nostdlib -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

+      else

+        # FIXME: insert proper C++ library support

+        _LT_AC_TAGVAR(ld_shlibs, $1)=no

+      fi

+      ;;

+    esac

+    ;;

+  hpux10*|hpux11*)

+    if test $with_gnu_ld = no; then

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'

+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

+

+      case $host_cpu in

+      hppa*64*|ia64*)

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir'

+        ;;

+      *)

+	_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'

+        ;;

+      esac

+    fi

+    case $host_cpu in

+    hppa*64*|ia64*)

+      _LT_AC_TAGVAR(hardcode_direct, $1)=no

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      ;;

+    *)

+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,

+					      # but as the default

+					      # location of the library.

+      ;;

+    esac

+

+    case $cc_basename in

+      CC*)

+	# FIXME: insert proper C++ library support

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+	;;

+      aCC*)

+	case $host_cpu in

+	hppa*64*)

+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

+	  ;;

+	ia64*)

+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

+	  ;;

+	*)

+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

+	  ;;

+	esac

+	# Commands to make compiler produce verbose output that lists

+	# what "hidden" libraries, object files and flags are used when

+	# linking a shared library.

+	#

+	# There doesn't appear to be a way to prevent this compiler from

+	# explicitly linking system object files so we need to strip them

+	# from the output so that they don't get included in the library

+	# dependencies.

+	output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | grep "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

+	;;

+      *)

+	if test "$GXX" = yes; then

+	  if test $with_gnu_ld = no; then

+	    case $host_cpu in

+	    hppa*64*)

+	      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

+	      ;;

+	    ia64*)

+	      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

+	      ;;

+	    *)

+	      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

+	      ;;

+	    esac

+	  fi

+	else

+	  # FIXME: insert proper C++ library support

+	  _LT_AC_TAGVAR(ld_shlibs, $1)=no

+	fi

+	;;

+    esac

+    ;;

+  interix3*)

+    _LT_AC_TAGVAR(hardcode_direct, $1)=no

+    _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'

+    _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'

+    # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.

+    # Instead, shared libraries are loaded at an image base (0x10000000 by

+    # default) and relocated if they conflict, which is a slow very memory

+    # consuming and fragmenting process.  To avoid this, we pick a random,

+    # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link

+    # time.  Moving up from 0x10000000 also allows more sbrk(2) space.

+    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'

+    _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'

+    ;;

+  irix5* | irix6*)

+    case $cc_basename in

+      CC*)

+	# SGI C++

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+

+	# Archives containing C++ object files must be created using

+	# "CC -ar", where "CC" is the IRIX C++ compiler.  This is

+	# necessary to make sure instantiated templates are included

+	# in the archive.

+	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs'

+	;;

+      *)

+	if test "$GXX" = yes; then

+	  if test "$with_gnu_ld" = no; then

+	    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+	  else

+	    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` -o $lib'

+	  fi

+	fi

+	_LT_AC_TAGVAR(link_all_deplibs, $1)=yes

+	;;

+    esac

+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

+    _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

+    ;;

+  linux*)

+    case $cc_basename in

+      KCC*)

+	# Kuck and Associates, Inc. (KAI) C++ Compiler

+

+	# KCC will only create a shared library if the output file

+	# ends with ".so" (or ".sl" for HP-UX), so rename the library

+	# to its proper name (with version) after linking.

+	_LT_AC_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib'

+	# Commands to make compiler produce verbose output that lists

+	# what "hidden" libraries, object files and flags are used when

+	# linking a shared library.

+	#

+	# There doesn't appear to be a way to prevent this compiler from

+	# explicitly linking system object files so we need to strip them

+	# from the output so that they don't get included in the library

+	# dependencies.

+	output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | grep "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

+

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath,$libdir'

+	_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'

+

+	# Archives containing C++ object files must be created using

+	# "CC -Bstatic", where "CC" is the KAI C++ compiler.

+	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'

+	;;

+      icpc*)

+	# Intel C++

+	with_gnu_ld=yes

+	# version 8.0 and above of icpc choke on multiply defined symbols

+	# if we add $predep_objects and $postdep_objects, however 7.1 and

+	# earlier do not add the objects themselves.

+	case `$CC -V 2>&1` in

+	*"Version 7."*)

+  	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'

+  	  _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+	  ;;

+	*)  # Version 8.0 or newer

+	  tmp_idyn=

+	  case $host_cpu in

+	    ia64*) tmp_idyn=' -i_dynamic';;

+	  esac

+  	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+	  _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+	  ;;

+	esac

+	_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'

+	_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'

+	_LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'

+	;;

+      pgCC*)

+        # Portland Group C++ compiler

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'

+  	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'

+

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'

+	_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'

+	_LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'

+        ;;

+      cxx*)

+	# Compaq C++

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname  -o $lib ${wl}-retain-symbols-file $wl$export_symbols'

+

+	runpath_var=LD_RUN_PATH

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'

+	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

+

+	# Commands to make compiler produce verbose output that lists

+	# what "hidden" libraries, object files and flags are used when

+	# linking a shared library.

+	#

+	# There doesn't appear to be a way to prevent this compiler from

+	# explicitly linking system object files so we need to strip them

+	# from the output so that they don't get included in the library

+	# dependencies.

+	output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

+	;;

+    esac

+    ;;

+  lynxos*)

+    # FIXME: insert proper C++ library support

+    _LT_AC_TAGVAR(ld_shlibs, $1)=no

+    ;;

+  m88k*)

+    # FIXME: insert proper C++ library support

+    _LT_AC_TAGVAR(ld_shlibs, $1)=no

+    ;;

+  mvs*)

+    case $cc_basename in

+      cxx*)

+	# FIXME: insert proper C++ library support

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+	;;

+      *)

+	# FIXME: insert proper C++ library support

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+	;;

+    esac

+    ;;

+  netbsd* | netbsdelf*-gnu | knetbsd*-gnu)

+    if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable  -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'

+      wlarc=

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'

+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+    fi

+    # Workaround some broken pre-1.5 toolchains

+    output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'

+    ;;

+  openbsd2*)

+    # C++ shared libraries are fairly broken

+    _LT_AC_TAGVAR(ld_shlibs, $1)=no

+    ;;

+  openbsd*)

+    _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+    _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'

+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'

+    if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

+      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib'

+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'

+      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'

+    fi

+    output_verbose_link_cmd='echo'

+    ;;

+  osf3*)

+    case $cc_basename in

+      KCC*)

+	# Kuck and Associates, Inc. (KAI) C++ Compiler

+

+	# KCC will only create a shared library if the output file

+	# ends with ".so" (or ".sl" for HP-UX), so rename the library

+	# to its proper name (with version) after linking.

+	_LT_AC_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'

+

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'

+	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

+

+	# Archives containing C++ object files must be created using

+	# "CC -Bstatic", where "CC" is the KAI C++ compiler.

+	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'

+

+	;;

+      RCC*)

+	# Rational C++ 2.4.1

+	# FIXME: insert proper C++ library support

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+	;;

+      cxx*)

+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && echo ${wl}-set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

+	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

+

+	# Commands to make compiler produce verbose output that lists

+	# what "hidden" libraries, object files and flags are used when

+	# linking a shared library.

+	#

+	# There doesn't appear to be a way to prevent this compiler from

+	# explicitly linking system object files so we need to strip them

+	# from the output so that they don't get included in the library

+	# dependencies.

+	output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld" | grep -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

+	;;

+      *)

+	if test "$GXX" = yes && test "$with_gnu_ld" = no; then

+	  _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'

+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+

+	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

+	  _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

+

+	  # Commands to make compiler produce verbose output that lists

+	  # what "hidden" libraries, object files and flags are used when

+	  # linking a shared library.

+	  output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"'

+

+	else

+	  # FIXME: insert proper C++ library support

+	  _LT_AC_TAGVAR(ld_shlibs, $1)=no

+	fi

+	;;

+    esac

+    ;;

+  osf4* | osf5*)

+    case $cc_basename in

+      KCC*)

+	# Kuck and Associates, Inc. (KAI) C++ Compiler

+

+	# KCC will only create a shared library if the output file

+	# ends with ".so" (or ".sl" for HP-UX), so rename the library

+	# to its proper name (with version) after linking.

+	_LT_AC_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'

+

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'

+	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

+

+	# Archives containing C++ object files must be created using

+	# the KAI C++ compiler.

+	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs'

+	;;

+      RCC*)

+	# Rational C++ 2.4.1

+	# FIXME: insert proper C++ library support

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+	;;

+      cxx*)

+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~

+	  echo "-hidden">> $lib.exp~

+	  $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname -Wl,-input -Wl,$lib.exp  `test -n "$verstring" && echo -set_version	$verstring` -update_registry ${output_objdir}/so_locations -o $lib~

+	  $rm $lib.exp'

+

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'

+	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

+

+	# Commands to make compiler produce verbose output that lists

+	# what "hidden" libraries, object files and flags are used when

+	# linking a shared library.

+	#

+	# There doesn't appear to be a way to prevent this compiler from

+	# explicitly linking system object files so we need to strip them

+	# from the output so that they don't get included in the library

+	# dependencies.

+	output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld" | grep -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

+	;;

+      *)

+	if test "$GXX" = yes && test "$with_gnu_ld" = no; then

+	  _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'

+	 _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+

+	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

+	  _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

+

+	  # Commands to make compiler produce verbose output that lists

+	  # what "hidden" libraries, object files and flags are used when

+	  # linking a shared library.

+	  output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"'

+

+	else

+	  # FIXME: insert proper C++ library support

+	  _LT_AC_TAGVAR(ld_shlibs, $1)=no

+	fi

+	;;

+    esac

+    ;;

+  psos*)

+    # FIXME: insert proper C++ library support

+    _LT_AC_TAGVAR(ld_shlibs, $1)=no

+    ;;

+  sunos4*)

+    case $cc_basename in

+      CC*)

+	# Sun C++ 4.x

+	# FIXME: insert proper C++ library support

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+	;;

+      lcc*)

+	# Lucid

+	# FIXME: insert proper C++ library support

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+	;;

+      *)

+	# FIXME: insert proper C++ library support

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+	;;

+    esac

+    ;;

+  solaris*)

+    case $cc_basename in

+      CC*)

+	# Sun C++ 4.2, 5.x and Centerline C++

+        _LT_AC_TAGVAR(archive_cmds_need_lc,$1)=yes

+	_LT_AC_TAGVAR(no_undefined_flag, $1)=' -zdefs'

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag}  -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

+	$CC -G${allow_undefined_flag}  ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'

+

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'

+	_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+	case $host_os in

+	  solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;

+	  *)

+	    # The C++ compiler is used as linker so we must use $wl

+	    # flag to pass the commands to the underlying system

+	    # linker. We must also pass each convience library through

+	    # to the system linker between allextract/defaultextract.

+	    # The C++ compiler will combine linker options so we

+	    # cannot just pass the convience library names through

+	    # without $wl.

+	    # Supported since Solaris 2.6 (maybe 2.5.1?)

+	    _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}-z ${wl}defaultextract'

+	    ;;

+	esac

+	_LT_AC_TAGVAR(link_all_deplibs, $1)=yes

+

+	output_verbose_link_cmd='echo'

+

+	# Archives containing C++ object files must be created using

+	# "CC -xar", where "CC" is the Sun C++ compiler.  This is

+	# necessary to make sure instantiated templates are included

+	# in the archive.

+	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'

+	;;

+      gcx*)

+	# Green Hills C++ Compiler

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'

+

+	# The C++ compiler must be used to create the archive.

+	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs'

+	;;

+      *)

+	# GNU C++ compiler with Solaris linker

+	if test "$GXX" = yes && test "$with_gnu_ld" = no; then

+	  _LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs'

+	  if $CC --version | grep -v '^2\.7' > /dev/null; then

+	    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'

+	    _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

+		$CC -shared -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'

+

+	    # Commands to make compiler produce verbose output that lists

+	    # what "hidden" libraries, object files and flags are used when

+	    # linking a shared library.

+	    output_verbose_link_cmd="$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep \"\-L\""

+	  else

+	    # g++ 2.7 appears to require `-G' NOT `-shared' on this

+	    # platform.

+	    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'

+	    _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

+		$CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'

+

+	    # Commands to make compiler produce verbose output that lists

+	    # what "hidden" libraries, object files and flags are used when

+	    # linking a shared library.

+	    output_verbose_link_cmd="$CC -G $CFLAGS -v conftest.$objext 2>&1 | grep \"\-L\""

+	  fi

+

+	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir'

+	fi

+	;;

+    esac

+    ;;

+  sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*)

+    _LT_AC_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'

+    _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

+    _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+    runpath_var='LD_RUN_PATH'

+

+    case $cc_basename in

+      CC*)

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+	;;

+      *)

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+	;;

+    esac

+    ;;

+  sysv5* | sco3.2v5* | sco5v6*)

+    # Note: We can NOT use -z defs as we might desire, because we do not

+    # link with -lc, and that would cause any symbols used from libc to

+    # always be unresolved, which means just about no library would

+    # ever link correctly.  If we're not using GNU ld we use -z text

+    # though, which does catch some bad symbols but isn't as heavy-handed

+    # as -z defs.

+    # For security reasons, it is highly recommended that you always

+    # use absolute paths for naming shared libraries, and exclude the

+    # DT_RUNPATH tag from executables and libraries.  But doing so

+    # requires that you compile everything twice, which is a pain.

+    # So that behaviour is only enabled if SCOABSPATH is set to a

+    # non-empty value in the environment.  Most likely only useful for

+    # creating official distributions of packages.

+    # This is a hack until libtool officially supports absolute path

+    # names for shared libraries.

+    _LT_AC_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'

+    _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs'

+    _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

+    _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'

+    _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':'

+    _LT_AC_TAGVAR(link_all_deplibs, $1)=yes

+    _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'

+    runpath_var='LD_RUN_PATH'

+

+    case $cc_basename in

+      CC*)

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	;;

+      *)

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	;;

+    esac

+    ;;

+  tandem*)

+    case $cc_basename in

+      NCC*)

+	# NonStop-UX NCC 3.20

+	# FIXME: insert proper C++ library support

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+	;;

+      *)

+	# FIXME: insert proper C++ library support

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+	;;

+    esac

+    ;;

+  vxworks*)

+    # FIXME: insert proper C++ library support

+    _LT_AC_TAGVAR(ld_shlibs, $1)=no

+    ;;

+  *)

+    # FIXME: insert proper C++ library support

+    _LT_AC_TAGVAR(ld_shlibs, $1)=no

+    ;;

+esac

+AC_MSG_RESULT([$_LT_AC_TAGVAR(ld_shlibs, $1)])

+test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no

+

+_LT_AC_TAGVAR(GCC, $1)="$GXX"

+_LT_AC_TAGVAR(LD, $1)="$LD"

+

+AC_LIBTOOL_POSTDEP_PREDEP($1)

+AC_LIBTOOL_PROG_COMPILER_PIC($1)

+AC_LIBTOOL_PROG_CC_C_O($1)

+AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)

+AC_LIBTOOL_PROG_LD_SHLIBS($1)

+AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)

+AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)

+

+AC_LIBTOOL_CONFIG($1)

+

+AC_LANG_POP

+CC=$lt_save_CC

+LDCXX=$LD

+LD=$lt_save_LD

+GCC=$lt_save_GCC

+with_gnu_ldcxx=$with_gnu_ld

+with_gnu_ld=$lt_save_with_gnu_ld

+lt_cv_path_LDCXX=$lt_cv_path_LD

+lt_cv_path_LD=$lt_save_path_LD

+lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld

+lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld

+])# AC_LIBTOOL_LANG_CXX_CONFIG

+

+# AC_LIBTOOL_POSTDEP_PREDEP([TAGNAME])

+# ------------------------------------

+# Figure out "hidden" library dependencies from verbose

+# compiler output when linking a shared library.

+# Parse the compiler output and extract the necessary

+# objects, libraries and library flags.

+AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP],[

+dnl we can't use the lt_simple_compile_test_code here,

+dnl because it contains code intended for an executable,

+dnl not a library.  It's possible we should let each

+dnl tag define a new lt_????_link_test_code variable,

+dnl but it's only used here...

+ifelse([$1],[],[cat > conftest.$ac_ext <<EOF

+int a;

+void foo (void) { a = 0; }

+EOF

+],[$1],[CXX],[cat > conftest.$ac_ext <<EOF

+class Foo

+{

+public:

+  Foo (void) { a = 0; }

+private:

+  int a;

+};

+EOF

+],[$1],[F77],[cat > conftest.$ac_ext <<EOF

+      subroutine foo

+      implicit none

+      integer*4 a

+      a=0

+      return

+      end

+EOF

+],[$1],[GCJ],[cat > conftest.$ac_ext <<EOF

+public class foo {

+  private int a;

+  public void bar (void) {

+    a = 0;

+  }

+};

+EOF

+])

+dnl Parse the compiler output and extract the necessary

+dnl objects, libraries and library flags.

+if AC_TRY_EVAL(ac_compile); then

+  # Parse the compiler output and extract the necessary

+  # objects, libraries and library flags.

+

+  # Sentinel used to keep track of whether or not we are before

+  # the conftest object file.

+  pre_test_object_deps_done=no

+

+  # The `*' in the case matches for architectures that use `case' in

+  # $output_verbose_cmd can trigger glob expansion during the loop

+  # eval without this substitution.

+  output_verbose_link_cmd=`$echo "X$output_verbose_link_cmd" | $Xsed -e "$no_glob_subst"`

+

+  for p in `eval $output_verbose_link_cmd`; do

+    case $p in

+

+    -L* | -R* | -l*)

+       # Some compilers place space between "-{L,R}" and the path.

+       # Remove the space.

+       if test $p = "-L" \

+	  || test $p = "-R"; then

+	 prev=$p

+	 continue

+       else

+	 prev=

+       fi

+

+       if test "$pre_test_object_deps_done" = no; then

+	 case $p in

+	 -L* | -R*)

+	   # Internal compiler library paths should come after those

+	   # provided the user.  The postdeps already come after the

+	   # user supplied libs so there is no need to process them.

+	   if test -z "$_LT_AC_TAGVAR(compiler_lib_search_path, $1)"; then

+	     _LT_AC_TAGVAR(compiler_lib_search_path, $1)="${prev}${p}"

+	   else

+	     _LT_AC_TAGVAR(compiler_lib_search_path, $1)="${_LT_AC_TAGVAR(compiler_lib_search_path, $1)} ${prev}${p}"

+	   fi

+	   ;;

+	 # The "-l" case would never come before the object being

+	 # linked, so don't bother handling this case.

+	 esac

+       else

+	 if test -z "$_LT_AC_TAGVAR(postdeps, $1)"; then

+	   _LT_AC_TAGVAR(postdeps, $1)="${prev}${p}"

+	 else

+	   _LT_AC_TAGVAR(postdeps, $1)="${_LT_AC_TAGVAR(postdeps, $1)} ${prev}${p}"

+	 fi

+       fi

+       ;;

+

+    *.$objext)

+       # This assumes that the test object file only shows up

+       # once in the compiler output.

+       if test "$p" = "conftest.$objext"; then

+	 pre_test_object_deps_done=yes

+	 continue

+       fi

+

+       if test "$pre_test_object_deps_done" = no; then

+	 if test -z "$_LT_AC_TAGVAR(predep_objects, $1)"; then

+	   _LT_AC_TAGVAR(predep_objects, $1)="$p"

+	 else

+	   _LT_AC_TAGVAR(predep_objects, $1)="$_LT_AC_TAGVAR(predep_objects, $1) $p"

+	 fi

+       else

+	 if test -z "$_LT_AC_TAGVAR(postdep_objects, $1)"; then

+	   _LT_AC_TAGVAR(postdep_objects, $1)="$p"

+	 else

+	   _LT_AC_TAGVAR(postdep_objects, $1)="$_LT_AC_TAGVAR(postdep_objects, $1) $p"

+	 fi

+       fi

+       ;;

+

+    *) ;; # Ignore the rest.

+

+    esac

+  done

+

+  # Clean up.

+  rm -f a.out a.exe

+else

+  echo "libtool.m4: error: problem compiling $1 test program"

+fi

+

+$rm -f confest.$objext

+

+# PORTME: override above test on systems where it is broken

+ifelse([$1],[CXX],

+[case $host_os in

+interix3*)

+  # Interix 3.5 installs completely hosed .la files for C++, so rather than

+  # hack all around it, let's just trust "g++" to DTRT.

+  _LT_AC_TAGVAR(predep_objects,$1)=

+  _LT_AC_TAGVAR(postdep_objects,$1)=

+  _LT_AC_TAGVAR(postdeps,$1)=

+  ;;

+

+solaris*)

+  case $cc_basename in

+  CC*)

+    # Adding this requires a known-good setup of shared libraries for

+    # Sun compiler versions before 5.6, else PIC objects from an old

+    # archive will be linked into the output, leading to subtle bugs.

+    _LT_AC_TAGVAR(postdeps,$1)='-lCstd -lCrun'

+    ;;

+  esac

+  ;;

+esac

+])

+

+case " $_LT_AC_TAGVAR(postdeps, $1) " in

+*" -lc "*) _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no ;;

+esac

+])# AC_LIBTOOL_POSTDEP_PREDEP

+

+# AC_LIBTOOL_LANG_F77_CONFIG

+# --------------------------

+# Ensure that the configuration vars for the C compiler are

+# suitably defined.  Those variables are subsequently used by

+# AC_LIBTOOL_CONFIG to write the compiler configuration to `libtool'.

+AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG], [_LT_AC_LANG_F77_CONFIG(F77)])

+AC_DEFUN([_LT_AC_LANG_F77_CONFIG],

+[AC_REQUIRE([AC_PROG_F77])

+AC_LANG_PUSH(Fortran 77)

+

+_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

+_LT_AC_TAGVAR(allow_undefined_flag, $1)=

+_LT_AC_TAGVAR(always_export_symbols, $1)=no

+_LT_AC_TAGVAR(archive_expsym_cmds, $1)=

+_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=

+_LT_AC_TAGVAR(hardcode_direct, $1)=no

+_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=

+_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=

+_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=

+_LT_AC_TAGVAR(hardcode_minus_L, $1)=no

+_LT_AC_TAGVAR(hardcode_automatic, $1)=no

+_LT_AC_TAGVAR(module_cmds, $1)=

+_LT_AC_TAGVAR(module_expsym_cmds, $1)=

+_LT_AC_TAGVAR(link_all_deplibs, $1)=unknown

+_LT_AC_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds

+_LT_AC_TAGVAR(no_undefined_flag, $1)=

+_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=

+_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=no

+

+# Source file extension for f77 test sources.

+ac_ext=f

+

+# Object file extension for compiled f77 test sources.

+objext=o

+_LT_AC_TAGVAR(objext, $1)=$objext

+

+# Code to be used in simple compile tests

+lt_simple_compile_test_code="      subroutine t\n      return\n      end\n"

+

+# Code to be used in simple link tests

+lt_simple_link_test_code="      program t\n      end\n"

+

+# ltmain only uses $CC for tagged configurations so make sure $CC is set.

+_LT_AC_SYS_COMPILER

+

+# save warnings/boilerplate of simple test code

+_LT_COMPILER_BOILERPLATE

+_LT_LINKER_BOILERPLATE

+

+# Allow CC to be a program name with arguments.

+lt_save_CC="$CC"

+CC=${F77-"f77"}

+compiler=$CC

+_LT_AC_TAGVAR(compiler, $1)=$CC

+_LT_CC_BASENAME([$compiler])

+

+AC_MSG_CHECKING([if libtool supports shared libraries])

+AC_MSG_RESULT([$can_build_shared])

+

+AC_MSG_CHECKING([whether to build shared libraries])

+test "$can_build_shared" = "no" && enable_shared=no

+

+# On AIX, shared libraries and static libraries use the same namespace, and

+# are all built from PIC.

+case $host_os in

+aix3*)

+  test "$enable_shared" = yes && enable_static=no

+  if test -n "$RANLIB"; then

+    archive_cmds="$archive_cmds~\$RANLIB \$lib"

+    postinstall_cmds='$RANLIB $lib'

+  fi

+  ;;

+aix4* | aix5*)

+  if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then

+    test "$enable_shared" = yes && enable_static=no

+  fi

+  ;;

+esac

+AC_MSG_RESULT([$enable_shared])

+

+AC_MSG_CHECKING([whether to build static libraries])

+# Make sure either enable_shared or enable_static is yes.

+test "$enable_shared" = yes || enable_static=yes

+AC_MSG_RESULT([$enable_static])

+

+_LT_AC_TAGVAR(GCC, $1)="$G77"

+_LT_AC_TAGVAR(LD, $1)="$LD"

+

+AC_LIBTOOL_PROG_COMPILER_PIC($1)

+AC_LIBTOOL_PROG_CC_C_O($1)

+AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)

+AC_LIBTOOL_PROG_LD_SHLIBS($1)

+AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)

+AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)

+

+AC_LIBTOOL_CONFIG($1)

+

+AC_LANG_POP

+CC="$lt_save_CC"

+])# AC_LIBTOOL_LANG_F77_CONFIG

+

+

+# AC_LIBTOOL_LANG_GCJ_CONFIG

+# --------------------------

+# Ensure that the configuration vars for the C compiler are

+# suitably defined.  Those variables are subsequently used by

+# AC_LIBTOOL_CONFIG to write the compiler configuration to `libtool'.

+AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG], [_LT_AC_LANG_GCJ_CONFIG(GCJ)])

+AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG],

+[AC_LANG_SAVE

+

+# Source file extension for Java test sources.

+ac_ext=java

+

+# Object file extension for compiled Java test sources.

+objext=o

+_LT_AC_TAGVAR(objext, $1)=$objext

+

+# Code to be used in simple compile tests

+lt_simple_compile_test_code="class foo {}\n"

+

+# Code to be used in simple link tests

+lt_simple_link_test_code='public class conftest { public static void main(String[[]] argv) {}; }\n'

+

+# ltmain only uses $CC for tagged configurations so make sure $CC is set.

+_LT_AC_SYS_COMPILER

+

+# save warnings/boilerplate of simple test code

+_LT_COMPILER_BOILERPLATE

+_LT_LINKER_BOILERPLATE

+

+# Allow CC to be a program name with arguments.

+lt_save_CC="$CC"

+CC=${GCJ-"gcj"}

+compiler=$CC

+_LT_AC_TAGVAR(compiler, $1)=$CC

+_LT_CC_BASENAME([$compiler])

+

+# GCJ did not exist at the time GCC didn't implicitly link libc in.

+_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

+

+_LT_AC_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds

+

+AC_LIBTOOL_PROG_COMPILER_NO_RTTI($1)

+AC_LIBTOOL_PROG_COMPILER_PIC($1)

+AC_LIBTOOL_PROG_CC_C_O($1)

+AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)

+AC_LIBTOOL_PROG_LD_SHLIBS($1)

+AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)

+AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)

+

+AC_LIBTOOL_CONFIG($1)

+

+AC_LANG_RESTORE

+CC="$lt_save_CC"

+])# AC_LIBTOOL_LANG_GCJ_CONFIG

+

+

+# AC_LIBTOOL_LANG_RC_CONFIG

+# -------------------------

+# Ensure that the configuration vars for the Windows resource compiler are

+# suitably defined.  Those variables are subsequently used by

+# AC_LIBTOOL_CONFIG to write the compiler configuration to `libtool'.

+AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG], [_LT_AC_LANG_RC_CONFIG(RC)])

+AC_DEFUN([_LT_AC_LANG_RC_CONFIG],

+[AC_LANG_SAVE

+

+# Source file extension for RC test sources.

+ac_ext=rc

+

+# Object file extension for compiled RC test sources.

+objext=o

+_LT_AC_TAGVAR(objext, $1)=$objext

+

+# Code to be used in simple compile tests

+lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }\n'

+

+# Code to be used in simple link tests

+lt_simple_link_test_code="$lt_simple_compile_test_code"

+

+# ltmain only uses $CC for tagged configurations so make sure $CC is set.

+_LT_AC_SYS_COMPILER

+

+# save warnings/boilerplate of simple test code

+_LT_COMPILER_BOILERPLATE

+_LT_LINKER_BOILERPLATE

+

+# Allow CC to be a program name with arguments.

+lt_save_CC="$CC"

+CC=${RC-"windres"}

+compiler=$CC

+_LT_AC_TAGVAR(compiler, $1)=$CC

+_LT_CC_BASENAME([$compiler])

+_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes

+

+AC_LIBTOOL_CONFIG($1)

+

+AC_LANG_RESTORE

+CC="$lt_save_CC"

+])# AC_LIBTOOL_LANG_RC_CONFIG

+

+

+# AC_LIBTOOL_CONFIG([TAGNAME])

+# ----------------------------

+# If TAGNAME is not passed, then create an initial libtool script

+# with a default configuration from the untagged config vars.  Otherwise

+# add code to config.status for appending the configuration named by

+# TAGNAME from the matching tagged config vars.

+AC_DEFUN([AC_LIBTOOL_CONFIG],

+[# The else clause should only fire when bootstrapping the

+# libtool distribution, otherwise you forgot to ship ltmain.sh

+# with your package, and you will get complaints that there are

+# no rules to generate ltmain.sh.

+if test -f "$ltmain"; then

+  # See if we are running on zsh, and set the options which allow our commands through

+  # without removal of \ escapes.

+  if test -n "${ZSH_VERSION+set}" ; then

+    setopt NO_GLOB_SUBST

+  fi

+  # Now quote all the things that may contain metacharacters while being

+  # careful not to overquote the AC_SUBSTed values.  We take copies of the

+  # variables and quote the copies for generation of the libtool script.

+  for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC LTCFLAGS NM \

+    SED SHELL STRIP \

+    libname_spec library_names_spec soname_spec extract_expsyms_cmds \

+    old_striplib striplib file_magic_cmd finish_cmds finish_eval \

+    deplibs_check_method reload_flag reload_cmds need_locks \

+    lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \

+    lt_cv_sys_global_symbol_to_c_name_address \

+    sys_lib_search_path_spec sys_lib_dlsearch_path_spec \

+    old_postinstall_cmds old_postuninstall_cmds \

+    _LT_AC_TAGVAR(compiler, $1) \

+    _LT_AC_TAGVAR(CC, $1) \

+    _LT_AC_TAGVAR(LD, $1) \

+    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1) \

+    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1) \

+    _LT_AC_TAGVAR(lt_prog_compiler_static, $1) \

+    _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) \

+    _LT_AC_TAGVAR(export_dynamic_flag_spec, $1) \

+    _LT_AC_TAGVAR(thread_safe_flag_spec, $1) \

+    _LT_AC_TAGVAR(whole_archive_flag_spec, $1) \

+    _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1) \

+    _LT_AC_TAGVAR(old_archive_cmds, $1) \

+    _LT_AC_TAGVAR(old_archive_from_new_cmds, $1) \

+    _LT_AC_TAGVAR(predep_objects, $1) \

+    _LT_AC_TAGVAR(postdep_objects, $1) \

+    _LT_AC_TAGVAR(predeps, $1) \

+    _LT_AC_TAGVAR(postdeps, $1) \

+    _LT_AC_TAGVAR(compiler_lib_search_path, $1) \

+    _LT_AC_TAGVAR(archive_cmds, $1) \

+    _LT_AC_TAGVAR(archive_expsym_cmds, $1) \

+    _LT_AC_TAGVAR(postinstall_cmds, $1) \

+    _LT_AC_TAGVAR(postuninstall_cmds, $1) \

+    _LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1) \

+    _LT_AC_TAGVAR(allow_undefined_flag, $1) \

+    _LT_AC_TAGVAR(no_undefined_flag, $1) \

+    _LT_AC_TAGVAR(export_symbols_cmds, $1) \

+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1) \

+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1) \

+    _LT_AC_TAGVAR(hardcode_libdir_separator, $1) \

+    _LT_AC_TAGVAR(hardcode_automatic, $1) \

+    _LT_AC_TAGVAR(module_cmds, $1) \

+    _LT_AC_TAGVAR(module_expsym_cmds, $1) \

+    _LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1) \

+    _LT_AC_TAGVAR(exclude_expsyms, $1) \

+    _LT_AC_TAGVAR(include_expsyms, $1); do

+

+    case $var in

+    _LT_AC_TAGVAR(old_archive_cmds, $1) | \

+    _LT_AC_TAGVAR(old_archive_from_new_cmds, $1) | \

+    _LT_AC_TAGVAR(archive_cmds, $1) | \

+    _LT_AC_TAGVAR(archive_expsym_cmds, $1) | \

+    _LT_AC_TAGVAR(module_cmds, $1) | \

+    _LT_AC_TAGVAR(module_expsym_cmds, $1) | \

+    _LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1) | \

+    _LT_AC_TAGVAR(export_symbols_cmds, $1) | \

+    extract_expsyms_cmds | reload_cmds | finish_cmds | \

+    postinstall_cmds | postuninstall_cmds | \

+    old_postinstall_cmds | old_postuninstall_cmds | \

+    sys_lib_search_path_spec | sys_lib_dlsearch_path_spec)

+      # Double-quote double-evaled strings.

+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\""

+      ;;

+    *)

+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\""

+      ;;

+    esac

+  done

+

+  case $lt_echo in

+  *'\[$]0 --fallback-echo"')

+    lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\[$]0 --fallback-echo"[$]/[$]0 --fallback-echo"/'`

+    ;;

+  esac

+

+ifelse([$1], [],

+  [cfgfile="${ofile}T"

+  trap "$rm \"$cfgfile\"; exit 1" 1 2 15

+  $rm -f "$cfgfile"

+  AC_MSG_NOTICE([creating $ofile])],

+  [cfgfile="$ofile"])

+

+  cat <<__EOF__ >> "$cfgfile"

+ifelse([$1], [],

+[#! $SHELL

+

+# `$echo "$cfgfile" | sed 's%^.*/%%'` - Provide generalized library-building support services.

+# Generated automatically by $PROGRAM (GNU $PACKAGE $VERSION$TIMESTAMP)

+# NOTE: Changes made to this file will be lost: look at ltmain.sh.

+#

+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001

+# Free Software Foundation, Inc.

+#

+# This file is part of GNU Libtool:

+# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996

+#

+# This program is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published by

+# the Free Software Foundation; either version 2 of the License, or

+# (at your option) any later version.

+#

+# This program is distributed in the hope that it will be useful, but

+# WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+# General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with this program; if not, write to the Free Software

+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+#

+# As a special exception to the GNU General Public License, if you

+# distribute this file as part of a program that contains a

+# configuration script generated by Autoconf, you may include it under

+# the same distribution terms that you use for the rest of that program.

+

+# A sed program that does not truncate output.

+SED=$lt_SED

+

+# Sed that helps us avoid accidentally triggering echo(1) options like -n.

+Xsed="$SED -e 1s/^X//"

+

+# The HP-UX ksh and POSIX shell print the target directory to stdout

+# if CDPATH is set.

+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

+

+# The names of the tagged configurations supported by this script.

+available_tags=

+

+# ### BEGIN LIBTOOL CONFIG],

+[# ### BEGIN LIBTOOL TAG CONFIG: $tagname])

+

+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:

+

+# Shell to use when invoking shell scripts.

+SHELL=$lt_SHELL

+

+# Whether or not to build shared libraries.

+build_libtool_libs=$enable_shared

+

+# Whether or not to build static libraries.

+build_old_libs=$enable_static

+

+# Whether or not to add -lc for building shared libraries.

+build_libtool_need_lc=$_LT_AC_TAGVAR(archive_cmds_need_lc, $1)

+

+# Whether or not to disallow shared libs when runtime libs are static

+allow_libtool_libs_with_static_runtimes=$_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)

+

+# Whether or not to optimize for fast installation.

+fast_install=$enable_fast_install

+

+# The host system.

+host_alias=$host_alias

+host=$host

+host_os=$host_os

+

+# The build system.

+build_alias=$build_alias

+build=$build

+build_os=$build_os

+

+# An echo program that does not interpret backslashes.

+echo=$lt_echo

+

+# The archiver.

+AR=$lt_AR

+AR_FLAGS=$lt_AR_FLAGS

+

+# A C compiler.

+LTCC=$lt_LTCC

+

+# LTCC compiler flags.

+LTCFLAGS=$lt_LTCFLAGS

+

+# A language-specific compiler.

+CC=$lt_[]_LT_AC_TAGVAR(compiler, $1)

+

+# Is the compiler the GNU C compiler?

+with_gcc=$_LT_AC_TAGVAR(GCC, $1)

+

+# An ERE matcher.

+EGREP=$lt_EGREP

+

+# The linker used to build libraries.

+LD=$lt_[]_LT_AC_TAGVAR(LD, $1)

+

+# Whether we need hard or soft links.

+LN_S=$lt_LN_S

+

+# A BSD-compatible nm program.

+NM=$lt_NM

+

+# A symbol stripping program

+STRIP=$lt_STRIP

+

+# Used to examine libraries when file_magic_cmd begins "file"

+MAGIC_CMD=$MAGIC_CMD

+

+# Used on cygwin: DLL creation program.

+DLLTOOL="$DLLTOOL"

+

+# Used on cygwin: object dumper.

+OBJDUMP="$OBJDUMP"

+

+# Used on cygwin: assembler.

+AS="$AS"

+

+# The name of the directory that contains temporary libtool files.

+objdir=$objdir

+

+# How to create reloadable object files.

+reload_flag=$lt_reload_flag

+reload_cmds=$lt_reload_cmds

+

+# How to pass a linker flag through the compiler.

+wl=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)

+

+# Object file suffix (normally "o").

+objext="$ac_objext"

+

+# Old archive suffix (normally "a").

+libext="$libext"

+

+# Shared library suffix (normally ".so").

+shrext_cmds='$shrext_cmds'

+

+# Executable file suffix (normally "").

+exeext="$exeext"

+

+# Additional compiler flags for building library objects.

+pic_flag=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)

+pic_mode=$pic_mode

+

+# What is the maximum length of a command?

+max_cmd_len=$lt_cv_sys_max_cmd_len

+

+# Does compiler simultaneously support -c and -o options?

+compiler_c_o=$lt_[]_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)

+

+# Must we lock files when doing compilation?

+need_locks=$lt_need_locks

+

+# Do we need the lib prefix for modules?

+need_lib_prefix=$need_lib_prefix

+

+# Do we need a version for libraries?

+need_version=$need_version

+

+# Whether dlopen is supported.

+dlopen_support=$enable_dlopen

+

+# Whether dlopen of programs is supported.

+dlopen_self=$enable_dlopen_self

+

+# Whether dlopen of statically linked programs is supported.

+dlopen_self_static=$enable_dlopen_self_static

+

+# Compiler flag to prevent dynamic linking.

+link_static_flag=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_static, $1)

+

+# Compiler flag to turn off builtin functions.

+no_builtin_flag=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)

+

+# Compiler flag to allow reflexive dlopens.

+export_dynamic_flag_spec=$lt_[]_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)

+

+# Compiler flag to generate shared objects directly from archives.

+whole_archive_flag_spec=$lt_[]_LT_AC_TAGVAR(whole_archive_flag_spec, $1)

+

+# Compiler flag to generate thread-safe objects.

+thread_safe_flag_spec=$lt_[]_LT_AC_TAGVAR(thread_safe_flag_spec, $1)

+

+# Library versioning type.

+version_type=$version_type

+

+# Format of library name prefix.

+libname_spec=$lt_libname_spec

+

+# List of archive names.  First name is the real one, the rest are links.

+# The last name is the one that the linker finds with -lNAME.

+library_names_spec=$lt_library_names_spec

+

+# The coded name of the library, if different from the real name.

+soname_spec=$lt_soname_spec

+

+# Commands used to build and install an old-style archive.

+RANLIB=$lt_RANLIB

+old_archive_cmds=$lt_[]_LT_AC_TAGVAR(old_archive_cmds, $1)

+old_postinstall_cmds=$lt_old_postinstall_cmds

+old_postuninstall_cmds=$lt_old_postuninstall_cmds

+

+# Create an old-style archive from a shared archive.

+old_archive_from_new_cmds=$lt_[]_LT_AC_TAGVAR(old_archive_from_new_cmds, $1)

+

+# Create a temporary old-style archive to link instead of a shared archive.

+old_archive_from_expsyms_cmds=$lt_[]_LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1)

+

+# Commands used to build and install a shared archive.

+archive_cmds=$lt_[]_LT_AC_TAGVAR(archive_cmds, $1)

+archive_expsym_cmds=$lt_[]_LT_AC_TAGVAR(archive_expsym_cmds, $1)

+postinstall_cmds=$lt_postinstall_cmds

+postuninstall_cmds=$lt_postuninstall_cmds

+

+# Commands used to build a loadable module (assumed same as above if empty)

+module_cmds=$lt_[]_LT_AC_TAGVAR(module_cmds, $1)

+module_expsym_cmds=$lt_[]_LT_AC_TAGVAR(module_expsym_cmds, $1)

+

+# Commands to strip libraries.

+old_striplib=$lt_old_striplib

+striplib=$lt_striplib

+

+# Dependencies to place before the objects being linked to create a

+# shared library.

+predep_objects=$lt_[]_LT_AC_TAGVAR(predep_objects, $1)

+

+# Dependencies to place after the objects being linked to create a

+# shared library.

+postdep_objects=$lt_[]_LT_AC_TAGVAR(postdep_objects, $1)

+

+# Dependencies to place before the objects being linked to create a

+# shared library.

+predeps=$lt_[]_LT_AC_TAGVAR(predeps, $1)

+

+# Dependencies to place after the objects being linked to create a

+# shared library.

+postdeps=$lt_[]_LT_AC_TAGVAR(postdeps, $1)

+

+# The library search path used internally by the compiler when linking

+# a shared library.

+compiler_lib_search_path=$lt_[]_LT_AC_TAGVAR(compiler_lib_search_path, $1)

+

+# Method to check whether dependent libraries are shared objects.

+deplibs_check_method=$lt_deplibs_check_method

+

+# Command to use when deplibs_check_method == file_magic.

+file_magic_cmd=$lt_file_magic_cmd

+

+# Flag that allows shared libraries with undefined symbols to be built.

+allow_undefined_flag=$lt_[]_LT_AC_TAGVAR(allow_undefined_flag, $1)

+

+# Flag that forces no undefined symbols.

+no_undefined_flag=$lt_[]_LT_AC_TAGVAR(no_undefined_flag, $1)

+

+# Commands used to finish a libtool library installation in a directory.

+finish_cmds=$lt_finish_cmds

+

+# Same as above, but a single script fragment to be evaled but not shown.

+finish_eval=$lt_finish_eval

+

+# Take the output of nm and produce a listing of raw symbols and C names.

+global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe

+

+# Transform the output of nm in a proper C declaration

+global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl

+

+# Transform the output of nm in a C name address pair

+global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address

+

+# This is the shared library runtime path variable.

+runpath_var=$runpath_var

+

+# This is the shared library path variable.

+shlibpath_var=$shlibpath_var

+

+# Is shlibpath searched before the hard-coded library search path?

+shlibpath_overrides_runpath=$shlibpath_overrides_runpath

+

+# How to hardcode a shared library path into an executable.

+hardcode_action=$_LT_AC_TAGVAR(hardcode_action, $1)

+

+# Whether we should hardcode library paths into libraries.

+hardcode_into_libs=$hardcode_into_libs

+

+# Flag to hardcode \$libdir into a binary during linking.

+# This must work even if \$libdir does not exist.

+hardcode_libdir_flag_spec=$lt_[]_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)

+

+# If ld is used when linking, flag to hardcode \$libdir into

+# a binary during linking. This must work even if \$libdir does

+# not exist.

+hardcode_libdir_flag_spec_ld=$lt_[]_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)

+

+# Whether we need a single -rpath flag with a separated argument.

+hardcode_libdir_separator=$lt_[]_LT_AC_TAGVAR(hardcode_libdir_separator, $1)

+

+# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the

+# resulting binary.

+hardcode_direct=$_LT_AC_TAGVAR(hardcode_direct, $1)

+

+# Set to yes if using the -LDIR flag during linking hardcodes DIR into the

+# resulting binary.

+hardcode_minus_L=$_LT_AC_TAGVAR(hardcode_minus_L, $1)

+

+# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into

+# the resulting binary.

+hardcode_shlibpath_var=$_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)

+

+# Set to yes if building a shared library automatically hardcodes DIR into the library

+# and all subsequent libraries and executables linked against it.

+hardcode_automatic=$_LT_AC_TAGVAR(hardcode_automatic, $1)

+

+# Variables whose values should be saved in libtool wrapper scripts and

+# restored at relink time.

+variables_saved_for_relink="$variables_saved_for_relink"

+

+# Whether libtool must link a program against all its dependency libraries.

+link_all_deplibs=$_LT_AC_TAGVAR(link_all_deplibs, $1)

+

+# Compile-time system search path for libraries

+sys_lib_search_path_spec=$lt_sys_lib_search_path_spec

+

+# Run-time system search path for libraries

+sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec

+

+# Fix the shell variable \$srcfile for the compiler.

+fix_srcfile_path="$_LT_AC_TAGVAR(fix_srcfile_path, $1)"

+

+# Set to yes if exported symbols are required.

+always_export_symbols=$_LT_AC_TAGVAR(always_export_symbols, $1)

+

+# The commands to list exported symbols.

+export_symbols_cmds=$lt_[]_LT_AC_TAGVAR(export_symbols_cmds, $1)

+

+# The commands to extract the exported symbol list from a shared archive.

+extract_expsyms_cmds=$lt_extract_expsyms_cmds

+

+# Symbols that should not be listed in the preloaded symbols.

+exclude_expsyms=$lt_[]_LT_AC_TAGVAR(exclude_expsyms, $1)

+

+# Symbols that must always be exported.

+include_expsyms=$lt_[]_LT_AC_TAGVAR(include_expsyms, $1)

+

+ifelse([$1],[],

+[# ### END LIBTOOL CONFIG],

+[# ### END LIBTOOL TAG CONFIG: $tagname])

+

+__EOF__

+

+ifelse([$1],[], [

+  case $host_os in

+  aix3*)

+    cat <<\EOF >> "$cfgfile"

+

+# AIX sometimes has problems with the GCC collect2 program.  For some

+# reason, if we set the COLLECT_NAMES environment variable, the problems

+# vanish in a puff of smoke.

+if test "X${COLLECT_NAMES+set}" != Xset; then

+  COLLECT_NAMES=

+  export COLLECT_NAMES

+fi

+EOF

+    ;;

+  esac

+

+  # We use sed instead of cat because bash on DJGPP gets confused if

+  # if finds mixed CR/LF and LF-only lines.  Since sed operates in

+  # text mode, it properly converts lines to CR/LF.  This bash problem

+  # is reportedly fixed, but why not run on old versions too?

+  sed '$q' "$ltmain" >> "$cfgfile" || (rm -f "$cfgfile"; exit 1)

+

+  mv -f "$cfgfile" "$ofile" || \

+    (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")

+  chmod +x "$ofile"

+])

+else

+  # If there is no Makefile yet, we rely on a make rule to execute

+  # `config.status --recheck' to rerun these tests and create the

+  # libtool script then.

+  ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'`

+  if test -f "$ltmain_in"; then

+    test -f Makefile && make "$ltmain"

+  fi

+fi

+])# AC_LIBTOOL_CONFIG

+

+

+# AC_LIBTOOL_PROG_COMPILER_NO_RTTI([TAGNAME])

+# -------------------------------------------

+AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI],

+[AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl

+

+_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=

+

+if test "$GCC" = yes; then

+  _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'

+

+  AC_LIBTOOL_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions],

+    lt_cv_prog_compiler_rtti_exceptions,

+    [-fno-rtti -fno-exceptions], [],

+    [_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"])

+fi

+])# AC_LIBTOOL_PROG_COMPILER_NO_RTTI

+

+

+# AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE

+# ---------------------------------

+AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE],

+[AC_REQUIRE([AC_CANONICAL_HOST])

+AC_REQUIRE([AC_PROG_NM])

+AC_REQUIRE([AC_OBJEXT])

+# Check for command to grab the raw symbol name followed by C symbol from nm.

+AC_MSG_CHECKING([command to parse $NM output from $compiler object])

+AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe],

+[

+# These are sane defaults that work on at least a few old systems.

+# [They come from Ultrix.  What could be older than Ultrix?!! ;)]

+

+# Character class describing NM global symbol codes.

+symcode='[[BCDEGRST]]'

+

+# Regexp to match symbols that can be accessed directly from C.

+sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)'

+

+# Transform an extracted symbol line into a proper C declaration

+lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern int \1;/p'"

+

+# Transform an extracted symbol line into symbol name and symbol address

+lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode \([[^ ]]*\) \([[^ ]]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"

+

+# Define system-specific variables.

+case $host_os in

+aix*)

+  symcode='[[BCDT]]'

+  ;;

+cygwin* | mingw* | pw32*)

+  symcode='[[ABCDGISTW]]'

+  ;;

+hpux*) # Its linker distinguishes data from code symbols

+  if test "$host_cpu" = ia64; then

+    symcode='[[ABCDEGRST]]'

+  fi

+  lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"

+  lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"

+  ;;

+linux*)

+  if test "$host_cpu" = ia64; then

+    symcode='[[ABCDGIRSTW]]'

+    lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"

+    lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"

+  fi

+  ;;

+irix* | nonstopux*)

+  symcode='[[BCDEGRST]]'

+  ;;

+osf*)

+  symcode='[[BCDEGQRST]]'

+  ;;

+solaris*)

+  symcode='[[BDRT]]'

+  ;;

+sco3.2v5*)

+  symcode='[[DT]]'

+  ;;

+sysv4.2uw2*)

+  symcode='[[DT]]'

+  ;;

+sysv5* | sco5v6* | unixware* | OpenUNIX*)

+  symcode='[[ABDT]]'

+  ;;

+sysv4)

+  symcode='[[DFNSTU]]'

+  ;;

+esac

+

+# Handle CRLF in mingw tool chain

+opt_cr=

+case $build_os in

+mingw*)

+  opt_cr=`echo 'x\{0,1\}' | tr x '\015'` # option cr in regexp

+  ;;

+esac

+

+# If we're using GNU nm, then use its standard symbol codes.

+case `$NM -V 2>&1` in

+*GNU* | *'with BFD'*)

+  symcode='[[ABCDGIRSTW]]' ;;

+esac

+

+# Try without a prefix undercore, then with it.

+for ac_symprfx in "" "_"; do

+

+  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.

+  symxfrm="\\1 $ac_symprfx\\2 \\2"

+

+  # Write the raw and C identifiers.

+  lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[ 	]]\($symcode$symcode*\)[[ 	]][[ 	]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"

+

+  # Check to see that the pipe works correctly.

+  pipe_works=no

+

+  rm -f conftest*

+  cat > conftest.$ac_ext <<EOF

+#ifdef __cplusplus

+extern "C" {

+#endif

+char nm_test_var;

+void nm_test_func(){}

+#ifdef __cplusplus

+}

+#endif

+int main(){nm_test_var='a';nm_test_func();return(0);}

+EOF

+

+  if AC_TRY_EVAL(ac_compile); then

+    # Now try to grab the symbols.

+    nlist=conftest.nm

+    if AC_TRY_EVAL(NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) && test -s "$nlist"; then

+      # Try sorting and uniquifying the output.

+      if sort "$nlist" | uniq > "$nlist"T; then

+	mv -f "$nlist"T "$nlist"

+      else

+	rm -f "$nlist"T

+      fi

+

+      # Make sure that we snagged all the symbols we need.

+      if grep ' nm_test_var$' "$nlist" >/dev/null; then

+	if grep ' nm_test_func$' "$nlist" >/dev/null; then

+	  cat <<EOF > conftest.$ac_ext

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+EOF

+	  # Now generate the symbol file.

+	  eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | grep -v main >> conftest.$ac_ext'

+

+	  cat <<EOF >> conftest.$ac_ext

+#if defined (__STDC__) && __STDC__

+# define lt_ptr_t void *

+#else

+# define lt_ptr_t char *

+# define const

+#endif

+

+/* The mapping between symbol names and symbols. */

+const struct {

+  const char *name;

+  lt_ptr_t address;

+}

+lt_preloaded_symbols[[]] =

+{

+EOF

+	  $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (lt_ptr_t) \&\2},/" < "$nlist" | grep -v main >> conftest.$ac_ext

+	  cat <<\EOF >> conftest.$ac_ext

+  {0, (lt_ptr_t) 0}

+};

+

+#ifdef __cplusplus

+}

+#endif

+EOF

+	  # Now try linking the two files.

+	  mv conftest.$ac_objext conftstm.$ac_objext

+	  lt_save_LIBS="$LIBS"

+	  lt_save_CFLAGS="$CFLAGS"

+	  LIBS="conftstm.$ac_objext"

+	  CFLAGS="$CFLAGS$_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)"

+	  if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then

+	    pipe_works=yes

+	  fi

+	  LIBS="$lt_save_LIBS"

+	  CFLAGS="$lt_save_CFLAGS"

+	else

+	  echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD

+	fi

+      else

+	echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD

+      fi

+    else

+      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD

+    fi

+  else

+    echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD

+    cat conftest.$ac_ext >&5

+  fi

+  rm -f conftest* conftst*

+

+  # Do not use the global_symbol_pipe unless it works.

+  if test "$pipe_works" = yes; then

+    break

+  else

+    lt_cv_sys_global_symbol_pipe=

+  fi

+done

+])

+if test -z "$lt_cv_sys_global_symbol_pipe"; then

+  lt_cv_sys_global_symbol_to_cdecl=

+fi

+if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then

+  AC_MSG_RESULT(failed)

+else

+  AC_MSG_RESULT(ok)

+fi

+]) # AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE

+

+

+# AC_LIBTOOL_PROG_COMPILER_PIC([TAGNAME])

+# ---------------------------------------

+AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC],

+[_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)=

+_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=

+_LT_AC_TAGVAR(lt_prog_compiler_static, $1)=

+

+AC_MSG_CHECKING([for $compiler option to produce PIC])

+ ifelse([$1],[CXX],[

+  # C++ specific cases for pic, static, wl, etc.

+  if test "$GXX" = yes; then

+    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'

+

+    case $host_os in

+    aix*)

+      # All AIX code is PIC.

+      if test "$host_cpu" = ia64; then

+	# AIX 5 now supports IA64 processor

+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

+      fi

+      ;;

+    amigaos*)

+      # FIXME: we need at least 68020 code to build shared libraries, but

+      # adding the `-m68020' flag to GCC prevents building anything better,

+      # like `-m68040'.

+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'

+      ;;

+    beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)

+      # PIC is the default for these OSes.

+      ;;

+    mingw* | os2* | pw32*)

+      # This hack is so that the source file can tell whether it is being

+      # built for inclusion in a dll (and should export symbols for example).

+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'

+      ;;

+    darwin* | rhapsody*)

+      # PIC is the default on this platform

+      # Common symbols not allowed in MH_DYLIB files

+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'

+      ;;

+    *djgpp*)

+      # DJGPP does not support shared libraries at all

+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=

+      ;;

+    interix3*)

+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.

+      # Instead, we relocate shared libraries at runtime.

+      ;;

+    sysv4*MP*)

+      if test -d /usr/nec; then

+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic

+      fi

+      ;;

+    hpux*)

+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but

+      # not for PA HP-UX.

+      case $host_cpu in

+      hppa*64*|ia64*)

+	;;

+      *)

+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'

+	;;

+      esac

+      ;;

+    *)

+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'

+      ;;

+    esac

+  else

+    case $host_os in

+      aix4* | aix5*)

+	# All AIX code is PIC.

+	if test "$host_cpu" = ia64; then

+	  # AIX 5 now supports IA64 processor

+	  _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

+	else

+	  _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'

+	fi

+	;;

+      chorus*)

+	case $cc_basename in

+	cxch68*)

+	  # Green Hills C++ Compiler

+	  # _LT_AC_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"

+	  ;;

+	esac

+	;;

+       darwin*)

+         # PIC is the default on this platform

+         # Common symbols not allowed in MH_DYLIB files

+         case $cc_basename in

+           xlc*)

+           _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-qnocommon'

+           _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+           ;;

+         esac

+       ;;

+      dgux*)

+	case $cc_basename in

+	  ec++*)

+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

+	    ;;

+	  ghcx*)

+	    # Green Hills C++ Compiler

+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      freebsd* | kfreebsd*-gnu | dragonfly*)

+	# FreeBSD uses GNU C++

+	;;

+      hpux9* | hpux10* | hpux11*)

+	case $cc_basename in

+	  CC*)

+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'

+	    if test "$host_cpu" != ia64; then

+	      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z'

+	    fi

+	    ;;

+	  aCC*)

+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'

+	    case $host_cpu in

+	    hppa*64*|ia64*)

+	      # +Z the default

+	      ;;

+	    *)

+	      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z'

+	      ;;

+	    esac

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      interix*)

+	# This is c89, which is MS Visual C++ (no shared libs)

+	# Anyone wants to do a port?

+	;;

+      irix5* | irix6* | nonstopux*)

+	case $cc_basename in

+	  CC*)

+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'

+	    # CC pic flag -KPIC is the default.

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      linux*)

+	case $cc_basename in

+	  KCC*)

+	    # KAI C++ Compiler

+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'

+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'

+	    ;;

+	  icpc* | ecpc*)

+	    # Intel C++

+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'

+	    ;;

+	  pgCC*)

+	    # Portland Group C++ compiler.

+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'

+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

+	    ;;

+	  cxx*)

+	    # Compaq C++

+	    # Make sure the PIC flag is empty.  It appears that all Alpha

+	    # Linux and Compaq Tru64 Unix objects are PIC.

+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=

+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      lynxos*)

+	;;

+      m88k*)

+	;;

+      mvs*)

+	case $cc_basename in

+	  cxx*)

+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall'

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      netbsd* | netbsdelf*-gnu | knetbsd*-gnu)

+	;;

+      osf3* | osf4* | osf5*)

+	case $cc_basename in

+	  KCC*)

+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'

+	    ;;

+	  RCC*)

+	    # Rational C++ 2.4.1

+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'

+	    ;;

+	  cxx*)

+	    # Digital/Compaq C++

+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+	    # Make sure the PIC flag is empty.  It appears that all Alpha

+	    # Linux and Compaq Tru64 Unix objects are PIC.

+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=

+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      psos*)

+	;;

+      solaris*)

+	case $cc_basename in

+	  CC*)

+	    # Sun C++ 4.2, 5.x and Centerline C++

+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '

+	    ;;

+	  gcx*)

+	    # Green Hills C++ Compiler

+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      sunos4*)

+	case $cc_basename in

+	  CC*)

+	    # Sun C++ 4.x

+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'

+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

+	    ;;

+	  lcc*)

+	    # Lucid

+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      tandem*)

+	case $cc_basename in

+	  NCC*)

+	    # NonStop-UX NCC 3.20

+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)

+	case $cc_basename in

+	  CC*)

+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

+	    ;;

+	esac

+	;;

+      vxworks*)

+	;;

+      *)

+	_LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no

+	;;

+    esac

+  fi

+],

+[

+  if test "$GCC" = yes; then

+    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'

+

+    case $host_os in

+      aix*)

+      # All AIX code is PIC.

+      if test "$host_cpu" = ia64; then

+	# AIX 5 now supports IA64 processor

+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

+      fi

+      ;;

+

+    amigaos*)

+      # FIXME: we need at least 68020 code to build shared libraries, but

+      # adding the `-m68020' flag to GCC prevents building anything better,

+      # like `-m68040'.

+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'

+      ;;

+

+    beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)

+      # PIC is the default for these OSes.

+      ;;

+

+    mingw* | pw32* | os2*)

+      # This hack is so that the source file can tell whether it is being

+      # built for inclusion in a dll (and should export symbols for example).

+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'

+      ;;

+

+    darwin* | rhapsody*)

+      # PIC is the default on this platform

+      # Common symbols not allowed in MH_DYLIB files

+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'

+      ;;

+

+    interix3*)

+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.

+      # Instead, we relocate shared libraries at runtime.

+      ;;

+

+    msdosdjgpp*)

+      # Just because we use GCC doesn't mean we suddenly get shared libraries

+      # on systems that don't support them.

+      _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no

+      enable_shared=no

+      ;;

+

+    sysv4*MP*)

+      if test -d /usr/nec; then

+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic

+      fi

+      ;;

+

+    hpux*)

+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but

+      # not for PA HP-UX.

+      case $host_cpu in

+      hppa*64*|ia64*)

+	# +Z the default

+	;;

+      *)

+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'

+	;;

+      esac

+      ;;

+

+    *)

+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'

+      ;;

+    esac

+  else

+    # PORTME Check for flag to pass linker flags through the system compiler.

+    case $host_os in

+    aix*)

+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+      if test "$host_cpu" = ia64; then

+	# AIX 5 now supports IA64 processor

+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

+      else

+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'

+      fi

+      ;;

+      darwin*)

+        # PIC is the default on this platform

+        # Common symbols not allowed in MH_DYLIB files

+       case $cc_basename in

+         xlc*)

+         _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-qnocommon'

+         _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+         ;;

+       esac

+       ;;

+

+    mingw* | pw32* | os2*)

+      # This hack is so that the source file can tell whether it is being

+      # built for inclusion in a dll (and should export symbols for example).

+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'

+      ;;

+

+    hpux9* | hpux10* | hpux11*)

+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but

+      # not for PA HP-UX.

+      case $host_cpu in

+      hppa*64*|ia64*)

+	# +Z the default

+	;;

+      *)

+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z'

+	;;

+      esac

+      # Is there a better lt_prog_compiler_static that works with the bundled CC?

+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'

+      ;;

+

+    irix5* | irix6* | nonstopux*)

+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+      # PIC (with -KPIC) is the default.

+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'

+      ;;

+

+    newsos6)

+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

+      ;;

+

+    linux*)

+      case $cc_basename in

+      icc* | ecc*)

+	_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'

+        ;;

+      pgcc* | pgf77* | pgf90* | pgf95*)

+        # Portland Group compilers (*not* the Pentium gcc compiler,

+	# which looks to be a dead project)

+	_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'

+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

+        ;;

+      ccc*)

+        _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+        # All Alpha code is PIC.

+        _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'

+        ;;

+      esac

+      ;;

+

+    osf3* | osf4* | osf5*)

+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+      # All OSF/1 code is PIC.

+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'

+      ;;

+

+    solaris*)

+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

+      case $cc_basename in

+      f77* | f90* | f95*)

+	_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ';;

+      *)

+	_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,';;

+      esac

+      ;;

+

+    sunos4*)

+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '

+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'

+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

+      ;;

+

+    sysv4 | sysv4.2uw2* | sysv4.3*)

+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

+      ;;

+

+    sysv4*MP*)

+      if test -d /usr/nec ;then

+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic'

+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

+      fi

+      ;;

+

+    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)

+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

+      ;;

+

+    unicos*)

+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

+      _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no

+      ;;

+

+    uts4*)

+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'

+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

+      ;;

+

+    *)

+      _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no

+      ;;

+    esac

+  fi

+])

+AC_MSG_RESULT([$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)])

+

+#

+# Check to make sure the PIC flag actually works.

+#

+if test -n "$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)"; then

+  AC_LIBTOOL_COMPILER_OPTION([if $compiler PIC flag $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1) works],

+    _LT_AC_TAGVAR(lt_prog_compiler_pic_works, $1),

+    [$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)ifelse([$1],[],[ -DPIC],[ifelse([$1],[CXX],[ -DPIC],[])])], [],

+    [case $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1) in

+     "" | " "*) ;;

+     *) _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)" ;;

+     esac],

+    [_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=

+     _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no])

+fi

+case $host_os in

+  # For platforms which do not support PIC, -DPIC is meaningless:

+  *djgpp*)

+    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=

+    ;;

+  *)

+    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)ifelse([$1],[],[ -DPIC],[ifelse([$1],[CXX],[ -DPIC],[])])"

+    ;;

+esac

+

+#

+# Check to make sure the static flag actually works.

+#

+wl=$_LT_AC_TAGVAR(lt_prog_compiler_wl, $1) eval lt_tmp_static_flag=\"$_LT_AC_TAGVAR(lt_prog_compiler_static, $1)\"

+AC_LIBTOOL_LINKER_OPTION([if $compiler static flag $lt_tmp_static_flag works],

+  _LT_AC_TAGVAR(lt_prog_compiler_static_works, $1),

+  $lt_tmp_static_flag,

+  [],

+  [_LT_AC_TAGVAR(lt_prog_compiler_static, $1)=])

+])

+

+

+# AC_LIBTOOL_PROG_LD_SHLIBS([TAGNAME])

+# ------------------------------------

+# See if the linker supports building shared libraries.

+AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS],

+[AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])

+ifelse([$1],[CXX],[

+  _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'

+  case $host_os in

+  aix4* | aix5*)

+    # If we're using GNU nm, then we don't want the "-C" option.

+    # -C means demangle to AIX nm, but means don't demangle with GNU nm

+    if $NM -V 2>&1 | grep 'GNU' > /dev/null; then

+      _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'

+    else

+      _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'

+    fi

+    ;;

+  pw32*)

+    _LT_AC_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds"

+  ;;

+  cygwin* | mingw*)

+    _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]] /s/.* \([[^ ]]*\)/\1 DATA/;/^.* __nm__/s/^.* __nm__\([[^ ]]*\) [[^ ]]*/\1 DATA/;/^I /d;/^[[AITW]] /s/.* //'\'' | sort | uniq > $export_symbols'

+  ;;

+  kfreebsd*-gnu)

+    _LT_AC_TAGVAR(link_all_deplibs, $1)=no

+  ;;

+  linux*)

+    _LT_AC_TAGVAR(link_all_deplibs, $1)=no

+  ;;

+  *)

+    _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'

+  ;;

+  esac

+],[

+  runpath_var=

+  _LT_AC_TAGVAR(allow_undefined_flag, $1)=

+  _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=no

+  _LT_AC_TAGVAR(archive_cmds, $1)=

+  _LT_AC_TAGVAR(archive_expsym_cmds, $1)=

+  _LT_AC_TAGVAR(old_archive_From_new_cmds, $1)=

+  _LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1)=

+  _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=

+  _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=

+  _LT_AC_TAGVAR(thread_safe_flag_spec, $1)=

+  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=

+  _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=

+  _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=

+  _LT_AC_TAGVAR(hardcode_direct, $1)=no

+  _LT_AC_TAGVAR(hardcode_minus_L, $1)=no

+  _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported

+  _LT_AC_TAGVAR(link_all_deplibs, $1)=unknown

+  _LT_AC_TAGVAR(hardcode_automatic, $1)=no

+  _LT_AC_TAGVAR(module_cmds, $1)=

+  _LT_AC_TAGVAR(module_expsym_cmds, $1)=

+  _LT_AC_TAGVAR(always_export_symbols, $1)=no

+  _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'

+  # include_expsyms should be a list of space-separated symbols to be *always*

+  # included in the symbol list

+  _LT_AC_TAGVAR(include_expsyms, $1)=

+  # exclude_expsyms can be an extended regexp of symbols to exclude

+  # it will be wrapped by ` (' and `)$', so one must not match beginning or

+  # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',

+  # as well as any symbol that contains `d'.

+  _LT_AC_TAGVAR(exclude_expsyms, $1)="_GLOBAL_OFFSET_TABLE_"

+  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out

+  # platforms (ab)use it in PIC code, but their linkers get confused if

+  # the symbol is explicitly referenced.  Since portable code cannot

+  # rely on this symbol name, it's probably fine to never include it in

+  # preloaded symbol tables.

+  extract_expsyms_cmds=

+  # Just being paranoid about ensuring that cc_basename is set.

+  _LT_CC_BASENAME([$compiler])

+  case $host_os in

+  cygwin* | mingw* | pw32*)

+    # FIXME: the MSVC++ port hasn't been tested in a loooong time

+    # When not using gcc, we currently assume that we are using

+    # Microsoft Visual C++.

+    if test "$GCC" != yes; then

+      with_gnu_ld=no

+    fi

+    ;;

+  interix*)

+    # we just hope/assume this is gcc and not c89 (= MSVC++)

+    with_gnu_ld=yes

+    ;;

+  openbsd*)

+    with_gnu_ld=no

+    ;;

+  esac

+

+  _LT_AC_TAGVAR(ld_shlibs, $1)=yes

+  if test "$with_gnu_ld" = yes; then

+    # If archive_cmds runs LD, not CC, wlarc should be empty

+    wlarc='${wl}'

+

+    # Set some defaults for GNU ld with shared library support. These

+    # are reset later if shared libraries are not supported. Putting them

+    # here allows them to be overridden if necessary.

+    runpath_var=LD_RUN_PATH

+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'

+    _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'

+    # ancient GNU ld didn't support --whole-archive et. al.

+    if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then

+	_LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'

+      else

+  	_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=

+    fi

+    supports_anon_versioning=no

+    case `$LD -v 2>/dev/null` in

+      *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11

+      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...

+      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...

+      *\ 2.11.*) ;; # other 2.11 versions

+      *) supports_anon_versioning=yes ;;

+    esac

+

+    # See if GNU ld supports shared libraries.

+    case $host_os in

+    aix3* | aix4* | aix5*)

+      # On AIX/PPC, the GNU linker is very broken

+      if test "$host_cpu" != ia64; then

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+	cat <<EOF 1>&2

+

+*** Warning: the GNU linker, at least up to release 2.9.1, is reported

+*** to be unable to reliably create shared libraries on AIX.

+*** Therefore, libtool is disabling shared libraries support.  If you

+*** really care for shared libraries, you may want to modify your PATH

+*** so that a non-GNU linker is found, and then restart.

+

+EOF

+      fi

+      ;;

+

+    amigaos*)

+      _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

+

+      # Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports

+      # that the semantics of dynamic libraries on AmigaOS, at least up

+      # to version 4, is to share data among multiple programs linked

+      # with the same dynamic library.  Since this doesn't match the

+      # behavior of shared libraries on other platforms, we can't use

+      # them.

+      _LT_AC_TAGVAR(ld_shlibs, $1)=no

+      ;;

+

+    beos*)

+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported

+	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc

+	# support --undefined.  This deserves some investigation.  FIXME

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+      else

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+      fi

+      ;;

+

+    cygwin* | mingw* | pw32*)

+      # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,

+      # as there is no search path for DLLs.

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

+      _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported

+      _LT_AC_TAGVAR(always_export_symbols, $1)=no

+      _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes

+      _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]] /s/.* \([[^ ]]*\)/\1 DATA/'\'' | $SED -e '\''/^[[AITW]] /s/.* //'\'' | sort | uniq > $export_symbols'

+

+      if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then

+        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'

+	# If the export-symbols file already is a .def file (1st line

+	# is EXPORTS), use it as is; otherwise, prepend...

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then

+	  cp $export_symbols $output_objdir/$soname.def;

+	else

+	  echo EXPORTS > $output_objdir/$soname.def;

+	  cat $export_symbols >> $output_objdir/$soname.def;

+	fi~

+	$CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'

+      else

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+      fi

+      ;;

+

+    interix3*)

+      _LT_AC_TAGVAR(hardcode_direct, $1)=no

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'

+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'

+      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.

+      # Instead, shared libraries are loaded at an image base (0x10000000 by

+      # default) and relocated if they conflict, which is a slow very memory

+      # consuming and fragmenting process.  To avoid this, we pick a random,

+      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link

+      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.

+      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'

+      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'

+      ;;

+

+    linux*)

+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	tmp_addflag=

+	case $cc_basename,$host_cpu in

+	pgcc*)				# Portland Group C compiler

+	  _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'

+	  tmp_addflag=' $pic_flag'

+	  ;;

+	pgf77* | pgf90* | pgf95*)	# Portland Group f77 and f90 compilers

+	  _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'

+	  tmp_addflag=' $pic_flag -Mnomain' ;;

+	ecc*,ia64* | icc*,ia64*)		# Intel C compiler on ia64

+	  tmp_addflag=' -i_dynamic' ;;

+	efc*,ia64* | ifort*,ia64*)	# Intel Fortran compiler on ia64

+	  tmp_addflag=' -i_dynamic -nofor_main' ;;

+	ifc* | ifort*)			# Intel Fortran compiler

+	  tmp_addflag=' -nofor_main' ;;

+	esac

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+

+	if test $supports_anon_versioning = yes; then

+	  _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $output_objdir/$libname.ver~

+  cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~

+  $echo "local: *; };" >> $output_objdir/$libname.ver~

+	  $CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'

+	fi

+	_LT_AC_TAGVAR(link_all_deplibs, $1)=no

+      else

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+      fi

+      ;;

+

+    netbsd* | netbsdelf*-gnu | knetbsd*-gnu)

+      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'

+	wlarc=

+      else

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+      fi

+      ;;

+

+    solaris*)

+      if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+	cat <<EOF 1>&2

+

+*** Warning: The releases 2.8.* of the GNU linker cannot reliably

+*** create shared libraries on Solaris systems.  Therefore, libtool

+*** is disabling shared libraries support.  We urge you to upgrade GNU

+*** binutils to release 2.9.1 or newer.  Another option is to modify

+*** your PATH or compiler configuration so that the native linker is

+*** used, and then restart.

+

+EOF

+      elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+      else

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+      fi

+      ;;

+

+    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)

+      case `$LD -v 2>&1` in

+        *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.1[[0-5]].*) 

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+	cat <<_LT_EOF 1>&2

+

+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not

+*** reliably create shared libraries on SCO systems.  Therefore, libtool

+*** is disabling shared libraries support.  We urge you to upgrade GNU

+*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify

+*** your PATH or compiler configuration so that the native linker is

+*** used, and then restart.

+

+_LT_EOF

+	;;

+	*)

+	  if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='`test -z "$SCOABSPATH" && echo ${wl}-rpath,$libdir`'

+	    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib'

+	    _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname,-retain-symbols-file,$export_symbols -o $lib'

+	  else

+	    _LT_AC_TAGVAR(ld_shlibs, $1)=no

+	  fi

+	;;

+      esac

+      ;;

+

+    sunos4*)

+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'

+      wlarc=

+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      ;;

+

+    *)

+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+      else

+	_LT_AC_TAGVAR(ld_shlibs, $1)=no

+      fi

+      ;;

+    esac

+

+    if test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no; then

+      runpath_var=

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=

+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=

+      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=

+    fi

+  else

+    # PORTME fill in a description of your system's linker (not GNU ld)

+    case $host_os in

+    aix3*)

+      _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported

+      _LT_AC_TAGVAR(always_export_symbols, $1)=yes

+      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'

+      # Note: this linker hardcodes the directories in LIBPATH if there

+      # are no directories specified by -L.

+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

+      if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then

+	# Neither direct hardcoding nor static linking is supported with a

+	# broken collect2.

+	_LT_AC_TAGVAR(hardcode_direct, $1)=unsupported

+      fi

+      ;;

+

+    aix4* | aix5*)

+      if test "$host_cpu" = ia64; then

+	# On IA64, the linker does run time linking by default, so we don't

+	# have to do anything special.

+	aix_use_runtimelinking=no

+	exp_sym_flag='-Bexport'

+	no_entry_flag=""

+      else

+	# If we're using GNU nm, then we don't want the "-C" option.

+	# -C means demangle to AIX nm, but means don't demangle with GNU nm

+	if $NM -V 2>&1 | grep 'GNU' > /dev/null; then

+	  _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'

+	else

+	  _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'

+	fi

+	aix_use_runtimelinking=no

+

+	# Test if we are trying to use run time linking or normal

+	# AIX style linking. If -brtl is somewhere in LDFLAGS, we

+	# need to do runtime linking.

+	case $host_os in aix4.[[23]]|aix4.[[23]].*|aix5*)

+	  for ld_flag in $LDFLAGS; do

+  	  if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then

+  	    aix_use_runtimelinking=yes

+  	    break

+  	  fi

+	  done

+	  ;;

+	esac

+

+	exp_sym_flag='-bexport'

+	no_entry_flag='-bnoentry'

+      fi

+

+      # When large executables or shared objects are built, AIX ld can

+      # have problems creating the table of contents.  If linking a library

+      # or program results in "error TOC overflow" add -mminimal-toc to

+      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not

+      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.

+

+      _LT_AC_TAGVAR(archive_cmds, $1)=''

+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':'

+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes

+

+      if test "$GCC" = yes; then

+	case $host_os in aix4.[[012]]|aix4.[[012]].*)

+	# We only want to do this on AIX 4.2 and lower, the check

+	# below for broken collect2 doesn't work under 4.3+

+	  collect2name=`${CC} -print-prog-name=collect2`

+	  if test -f "$collect2name" && \

+  	   strings "$collect2name" | grep resolve_lib_name >/dev/null

+	  then

+  	  # We have reworked collect2

+  	  _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+	  else

+  	  # We have old collect2

+  	  _LT_AC_TAGVAR(hardcode_direct, $1)=unsupported

+  	  # It fails to find uninstalled libraries when the uninstalled

+  	  # path is not listed in the libpath.  Setting hardcode_minus_L

+  	  # to unsupported forces relinking

+  	  _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

+  	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

+  	  _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=

+	  fi

+	  ;;

+	esac

+	shared_flag='-shared'

+	if test "$aix_use_runtimelinking" = yes; then

+	  shared_flag="$shared_flag "'${wl}-G'

+	fi

+      else

+	# not using gcc

+	if test "$host_cpu" = ia64; then

+  	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release

+  	# chokes on -Wl,-G. The following line is correct:

+	  shared_flag='-G'

+	else

+	  if test "$aix_use_runtimelinking" = yes; then

+	    shared_flag='${wl}-G'

+	  else

+	    shared_flag='${wl}-bM:SRE'

+	  fi

+	fi

+      fi

+

+      # It seems that -bexpall does not export symbols beginning with

+      # underscore (_), so it is better to generate a list of symbols to export.

+      _LT_AC_TAGVAR(always_export_symbols, $1)=yes

+      if test "$aix_use_runtimelinking" = yes; then

+	# Warning - without using the other runtime loading flags (-brtl),

+	# -berok will link without error, but may produce a broken library.

+	_LT_AC_TAGVAR(allow_undefined_flag, $1)='-berok'

+       # Determine the default libpath from the value encoded in an empty executable.

+       _LT_AC_SYS_LIBPATH_AIX

+       _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"

+       else

+	if test "$host_cpu" = ia64; then

+	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'

+	  _LT_AC_TAGVAR(allow_undefined_flag, $1)="-z nodefs"

+	  _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"

+	else

+	 # Determine the default libpath from the value encoded in an empty executable.

+	 _LT_AC_SYS_LIBPATH_AIX

+	 _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"

+	  # Warning - without using the other run time loading flags,

+	  # -berok will link without error, but may produce a broken library.

+	  _LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'

+	  _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'

+	  # Exported symbols can be pulled into shared objects from archives

+	  _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='$convenience'

+	  _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes

+	  # This is similar to how AIX traditionally builds its shared libraries.

+	  _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'

+	fi

+      fi

+      ;;

+

+    amigaos*)

+      _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

+      # see comment about different semantics on the GNU ld section

+      _LT_AC_TAGVAR(ld_shlibs, $1)=no

+      ;;

+

+    bsdi[[45]]*)

+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic

+      ;;

+

+    cygwin* | mingw* | pw32*)

+      # When not using gcc, we currently assume that we are using

+      # Microsoft Visual C++.

+      # hardcode_libdir_flag_spec is actually meaningless, as there is

+      # no search path for DLLs.

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=' '

+      _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported

+      # Tell ltmain to make .lib files, not .a files.

+      libext=lib

+      # Tell ltmain to make .dll files, not .so files.

+      shrext_cmds=".dll"

+      # FIXME: Setting linknames here is a bad hack.

+      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames='

+      # The linker will automatically build a .lib file if we build a DLL.

+      _LT_AC_TAGVAR(old_archive_From_new_cmds, $1)='true'

+      # FIXME: Should let the user specify the lib program.

+      _LT_AC_TAGVAR(old_archive_cmds, $1)='lib /OUT:$oldlib$oldobjs$old_deplibs'

+      _LT_AC_TAGVAR(fix_srcfile_path, $1)='`cygpath -w "$srcfile"`'

+      _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes

+      ;;

+

+    darwin* | rhapsody*)

+      case $host_os in

+        rhapsody* | darwin1.[[012]])

+         _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}suppress'

+         ;;

+       *) # Darwin 1.3 on

+         if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then

+           _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'

+         else

+           case ${MACOSX_DEPLOYMENT_TARGET} in

+             10.[[012]])

+               _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'

+               ;;

+             10.*)

+               _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}dynamic_lookup'

+               ;;

+           esac

+         fi

+         ;;

+      esac

+      _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

+      _LT_AC_TAGVAR(hardcode_direct, $1)=no

+      _LT_AC_TAGVAR(hardcode_automatic, $1)=yes

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported

+      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=''

+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes

+    if test "$GCC" = yes ; then

+    	output_verbose_link_cmd='echo'

+        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'

+      _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'

+      # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds

+      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+      _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+    else

+      case $cc_basename in

+        xlc*)

+         output_verbose_link_cmd='echo'

+         _LT_AC_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'

+         _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'

+          # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds

+         _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+          _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+          ;;

+       *)

+         _LT_AC_TAGVAR(ld_shlibs, $1)=no

+          ;;

+      esac

+    fi

+      ;;

+

+    dgux*)

+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      ;;

+

+    freebsd1*)

+      _LT_AC_TAGVAR(ld_shlibs, $1)=no

+      ;;

+

+    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor

+    # support.  Future versions do this automatically, but an explicit c++rt0.o

+    # does not break anything, and helps significantly (at the cost of a little

+    # extra space).

+    freebsd2.2*)

+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'

+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      ;;

+

+    # Unfortunately, older versions of FreeBSD 2 do not have this feature.

+    freebsd2*)

+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'

+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      ;;

+

+    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.

+    freebsd* | dragonfly*)

+      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'

+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      ;;

+      

+    # GNU/kFreeBSD uses gcc -shared to do shared libraries.

+    kfreebsd*-gnu)

+      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'

+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      _LT_AC_TAGVAR(link_all_deplibs, $1)=no

+      ;;

+

+    hpux9*)

+      if test "$GCC" = yes; then

+	_LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

+      else

+	_LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

+      fi

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'

+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+

+      # hardcode_minus_L: Not really in the search PATH,

+      # but as the default location of the library.

+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'

+      ;;

+

+    hpux10*)

+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

+      else

+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'

+      fi

+      if test "$with_gnu_ld" = no; then

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'

+	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

+

+	_LT_AC_TAGVAR(hardcode_direct, $1)=yes

+	_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'

+

+	# hardcode_minus_L: Not really in the search PATH,

+	# but as the default location of the library.

+	_LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

+      fi

+      ;;

+

+    hpux11*)

+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then

+	case $host_cpu in

+	hppa*64*)

+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	ia64*)

+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	*)

+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	esac

+      else

+	case $host_cpu in

+	hppa*64*)

+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	ia64*)

+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	*)

+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	esac

+      fi

+      if test "$with_gnu_ld" = no; then

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'

+	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

+

+	case $host_cpu in

+	hppa*64*|ia64*)

+	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir'

+	  _LT_AC_TAGVAR(hardcode_direct, $1)=no

+	  _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+	  ;;

+	*)

+	  _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+	  _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'

+

+	  # hardcode_minus_L: Not really in the search PATH,

+	  # but as the default location of the library.

+	  _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

+	  ;;

+	esac

+      fi

+      ;;

+

+    irix5* | irix6* | nonstopux*)

+      if test "$GCC" = yes; then

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+      else

+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='-rpath $libdir'

+      fi

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes

+      ;;

+

+    netbsd* | netbsdelf*-gnu | knetbsd*-gnu)

+      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out

+      else

+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF

+      fi

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'

+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      ;;

+

+    newsos6)

+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      ;;

+

+    openbsd*)

+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'

+	_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'

+      else

+       case $host_os in

+	 openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*)

+	   _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'

+	   _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'

+	   ;;

+	 *)

+	   _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'

+	   _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'

+	   ;;

+       esac

+      fi

+      ;;

+

+    os2*)

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

+      _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported

+      _LT_AC_TAGVAR(archive_cmds, $1)='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'

+      _LT_AC_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'

+      ;;

+

+    osf3*)

+      if test "$GCC" = yes; then

+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+      else

+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'

+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+      fi

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

+      ;;

+

+    osf4* | osf5*)	# as osf3* with the addition of -msym flag

+      if test "$GCC" = yes; then

+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

+      else

+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'

+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~

+	$LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib~$rm $lib.exp'

+

+	# Both c and cxx compiler support -rpath directly

+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'

+      fi

+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

+      ;;

+

+    solaris*)

+      _LT_AC_TAGVAR(no_undefined_flag, $1)=' -z text'

+      if test "$GCC" = yes; then

+	wlarc='${wl}'

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

+	  $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp'

+      else

+	wlarc=''

+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

+  	$LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'

+      fi

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      case $host_os in

+      solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;

+      *)

+ 	# The compiler driver will combine linker options so we

+ 	# cannot just pass the convience library names through

+ 	# without $wl, iff we do not link with $LD.

+ 	# Luckily, gcc supports the same syntax we need for Sun Studio.

+ 	# Supported since Solaris 2.6 (maybe 2.5.1?)

+ 	case $wlarc in

+ 	'')

+ 	  _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' ;;

+ 	*)

+ 	  _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}-z ${wl}defaultextract' ;;

+ 	esac ;;

+      esac

+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes

+      ;;

+

+    sunos4*)

+      if test "x$host_vendor" = xsequent; then

+	# Use $CC to link under sequent, because it throws in some extra .o

+	# files that make .init and .fini sections work.

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'

+      else

+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'

+      fi

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes

+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      ;;

+

+    sysv4)

+      case $host_vendor in

+	sni)

+	  _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+	  _LT_AC_TAGVAR(hardcode_direct, $1)=yes # is this really true???

+	;;

+	siemens)

+	  ## LD is ld it makes a PLAMLIB

+	  ## CC just makes a GrossModule.

+	  _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags'

+	  _LT_AC_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs'

+	  _LT_AC_TAGVAR(hardcode_direct, $1)=no

+        ;;

+	motorola)

+	  _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+	  _LT_AC_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie

+	;;

+      esac

+      runpath_var='LD_RUN_PATH'

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      ;;

+

+    sysv4.3*)

+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport'

+      ;;

+

+    sysv4*MP*)

+      if test -d /usr/nec; then

+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+	_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+	runpath_var=LD_RUN_PATH

+	hardcode_runpath_var=yes

+	_LT_AC_TAGVAR(ld_shlibs, $1)=yes

+      fi

+      ;;

+

+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7*)

+      _LT_AC_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'

+      _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      runpath_var='LD_RUN_PATH'

+

+      if test "$GCC" = yes; then

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+      else

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+      fi

+      ;;

+

+    sysv5* | sco3.2v5* | sco5v6*)

+      # Note: We can NOT use -z defs as we might desire, because we do not

+      # link with -lc, and that would cause any symbols used from libc to

+      # always be unresolved, which means just about no library would

+      # ever link correctly.  If we're not using GNU ld we use -z text

+      # though, which does catch some bad symbols but isn't as heavy-handed

+      # as -z defs.

+      _LT_AC_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'

+      _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs'

+      _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'

+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':'

+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes

+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'

+      runpath_var='LD_RUN_PATH'

+

+      if test "$GCC" = yes; then

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+      else

+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+      fi

+      ;;

+

+    uts4*)

+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

+      ;;

+

+    *)

+      _LT_AC_TAGVAR(ld_shlibs, $1)=no

+      ;;

+    esac

+  fi

+])

+AC_MSG_RESULT([$_LT_AC_TAGVAR(ld_shlibs, $1)])

+test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no

+

+#

+# Do we need to explicitly link libc?

+#

+case "x$_LT_AC_TAGVAR(archive_cmds_need_lc, $1)" in

+x|xyes)

+  # Assume -lc should be added

+  _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes

+

+  if test "$enable_shared" = yes && test "$GCC" = yes; then

+    case $_LT_AC_TAGVAR(archive_cmds, $1) in

+    *'~'*)

+      # FIXME: we may have to deal with multi-command sequences.

+      ;;

+    '$CC '*)

+      # Test whether the compiler implicitly links with -lc since on some

+      # systems, -lgcc has to come before -lc. If gcc already passes -lc

+      # to ld, don't add -lc before -lgcc.

+      AC_MSG_CHECKING([whether -lc should be explicitly linked in])

+      $rm conftest*

+      printf "$lt_simple_compile_test_code" > conftest.$ac_ext

+

+      if AC_TRY_EVAL(ac_compile) 2>conftest.err; then

+        soname=conftest

+        lib=conftest

+        libobjs=conftest.$ac_objext

+        deplibs=

+        wl=$_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)

+	pic_flag=$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)

+        compiler_flags=-v

+        linker_flags=-v

+        verstring=

+        output_objdir=.

+        libname=conftest

+        lt_save_allow_undefined_flag=$_LT_AC_TAGVAR(allow_undefined_flag, $1)

+        _LT_AC_TAGVAR(allow_undefined_flag, $1)=

+        if AC_TRY_EVAL(_LT_AC_TAGVAR(archive_cmds, $1) 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1)

+        then

+	  _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

+        else

+	  _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes

+        fi

+        _LT_AC_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag

+      else

+        cat conftest.err 1>&5

+      fi

+      $rm conftest*

+      AC_MSG_RESULT([$_LT_AC_TAGVAR(archive_cmds_need_lc, $1)])

+      ;;

+    esac

+  fi

+  ;;

+esac

+])# AC_LIBTOOL_PROG_LD_SHLIBS

+

+

+# _LT_AC_FILE_LTDLL_C

+# -------------------

+# Be careful that the start marker always follows a newline.

+AC_DEFUN([_LT_AC_FILE_LTDLL_C], [

+# /* ltdll.c starts here */

+# #define WIN32_LEAN_AND_MEAN

+# #include <windows.h>

+# #undef WIN32_LEAN_AND_MEAN

+# #include <stdio.h>

+#

+# #ifndef __CYGWIN__

+# #  ifdef __CYGWIN32__

+# #    define __CYGWIN__ __CYGWIN32__

+# #  endif

+# #endif

+#

+# #ifdef __cplusplus

+# extern "C" {

+# #endif

+# BOOL APIENTRY DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved);

+# #ifdef __cplusplus

+# }

+# #endif

+#

+# #ifdef __CYGWIN__

+# #include <cygwin/cygwin_dll.h>

+# DECLARE_CYGWIN_DLL( DllMain );

+# #endif

+# HINSTANCE __hDllInstance_base;

+#

+# BOOL APIENTRY

+# DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved)

+# {

+#   __hDllInstance_base = hInst;

+#   return TRUE;

+# }

+# /* ltdll.c ends here */

+])# _LT_AC_FILE_LTDLL_C

+

+

+# _LT_AC_TAGVAR(VARNAME, [TAGNAME])

+# ---------------------------------

+AC_DEFUN([_LT_AC_TAGVAR], [ifelse([$2], [], [$1], [$1_$2])])

+

+

+# old names

+AC_DEFUN([AM_PROG_LIBTOOL],   [AC_PROG_LIBTOOL])

+AC_DEFUN([AM_ENABLE_SHARED],  [AC_ENABLE_SHARED($@)])

+AC_DEFUN([AM_ENABLE_STATIC],  [AC_ENABLE_STATIC($@)])

+AC_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)])

+AC_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)])

+AC_DEFUN([AM_PROG_LD],        [AC_PROG_LD])

+AC_DEFUN([AM_PROG_NM],        [AC_PROG_NM])

+

+# This is just to silence aclocal about the macro not being used

+ifelse([AC_DISABLE_FAST_INSTALL])

+

+AC_DEFUN([LT_AC_PROG_GCJ],

+[AC_CHECK_TOOL(GCJ, gcj, no)

+  test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2"

+  AC_SUBST(GCJFLAGS)

+])

+

+AC_DEFUN([LT_AC_PROG_RC],

+[AC_CHECK_TOOL(RC, windres, no)

+])

+

+# NOTE: This macro has been submitted for inclusion into   #

+#  GNU Autoconf as AC_PROG_SED.  When it is available in   #

+#  a released version of Autoconf we should remove this    #

+#  macro and use it instead.                               #

+# LT_AC_PROG_SED

+# --------------

+# Check for a fully-functional sed program, that truncates

+# as few characters as possible.  Prefer GNU sed if found.

+AC_DEFUN([LT_AC_PROG_SED],

+[AC_MSG_CHECKING([for a sed that does not truncate output])

+AC_CACHE_VAL(lt_cv_path_SED,

+[# Loop through the user's path and test for sed and gsed.

+# Then use that list of sed's as ones to test for truncation.

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for lt_ac_prog in sed gsed; do

+    for ac_exec_ext in '' $ac_executable_extensions; do

+      if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then

+        lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext"

+      fi

+    done

+  done

+done

+lt_ac_max=0

+lt_ac_count=0

+# Add /usr/xpg4/bin/sed as it is typically found on Solaris

+# along with /bin/sed that truncates output.

+for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do

+  test ! -f $lt_ac_sed && continue

+  cat /dev/null > conftest.in

+  lt_ac_count=0

+  echo $ECHO_N "0123456789$ECHO_C" >conftest.in

+  # Check for GNU sed and select it if it is found.

+  if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then

+    lt_cv_path_SED=$lt_ac_sed

+    break

+  fi

+  while true; do

+    cat conftest.in conftest.in >conftest.tmp

+    mv conftest.tmp conftest.in

+    cp conftest.in conftest.nl

+    echo >>conftest.nl

+    $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break

+    cmp -s conftest.out conftest.nl || break

+    # 10000 chars as input seems more than enough

+    test $lt_ac_count -gt 10 && break

+    lt_ac_count=`expr $lt_ac_count + 1`

+    if test $lt_ac_count -gt $lt_ac_max; then

+      lt_ac_max=$lt_ac_count

+      lt_cv_path_SED=$lt_ac_sed

+    fi

+  done

+done

+])

+SED=$lt_cv_path_SED

+AC_MSG_RESULT([$SED])

+])

+

+# Copyright (C) 2002, 2003, 2005  Free Software Foundation, Inc.

+#

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# AM_AUTOMAKE_VERSION(VERSION)

+# ----------------------------

+# Automake X.Y traces this macro to ensure aclocal.m4 has been

+# generated from the m4 files accompanying Automake X.Y.

+AC_DEFUN([AM_AUTOMAKE_VERSION], [am__api_version="1.9"])

+

+# AM_SET_CURRENT_AUTOMAKE_VERSION

+# -------------------------------

+# Call AM_AUTOMAKE_VERSION so it can be traced.

+# This function is AC_REQUIREd by AC_INIT_AUTOMAKE.

+AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],

+	 [AM_AUTOMAKE_VERSION([1.9.6])])

+

+# AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-

+

+# Copyright (C) 2001, 2003, 2005  Free Software Foundation, Inc.

+#

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets

+# $ac_aux_dir to `$srcdir/foo'.  In other projects, it is set to

+# `$srcdir', `$srcdir/..', or `$srcdir/../..'.

+#

+# Of course, Automake must honor this variable whenever it calls a

+# tool from the auxiliary directory.  The problem is that $srcdir (and

+# therefore $ac_aux_dir as well) can be either absolute or relative,

+# depending on how configure is run.  This is pretty annoying, since

+# it makes $ac_aux_dir quite unusable in subdirectories: in the top

+# source directory, any form will work fine, but in subdirectories a

+# relative path needs to be adjusted first.

+#

+# $ac_aux_dir/missing

+#    fails when called from a subdirectory if $ac_aux_dir is relative

+# $top_srcdir/$ac_aux_dir/missing

+#    fails if $ac_aux_dir is absolute,

+#    fails when called from a subdirectory in a VPATH build with

+#          a relative $ac_aux_dir

+#

+# The reason of the latter failure is that $top_srcdir and $ac_aux_dir

+# are both prefixed by $srcdir.  In an in-source build this is usually

+# harmless because $srcdir is `.', but things will broke when you

+# start a VPATH build or use an absolute $srcdir.

+#

+# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,

+# iff we strip the leading $srcdir from $ac_aux_dir.  That would be:

+#   am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"`

+# and then we would define $MISSING as

+#   MISSING="\${SHELL} $am_aux_dir/missing"

+# This will work as long as MISSING is not called from configure, because

+# unfortunately $(top_srcdir) has no meaning in configure.

+# However there are other variables, like CC, which are often used in

+# configure, and could therefore not use this "fixed" $ac_aux_dir.

+#

+# Another solution, used here, is to always expand $ac_aux_dir to an

+# absolute PATH.  The drawback is that using absolute paths prevent a

+# configured tree to be moved without reconfiguration.

+

+AC_DEFUN([AM_AUX_DIR_EXPAND],

+[dnl Rely on autoconf to set up CDPATH properly.

+AC_PREREQ([2.50])dnl

+# expand $ac_aux_dir to an absolute path

+am_aux_dir=`cd $ac_aux_dir && pwd`

+])

+

+# AM_CONDITIONAL                                            -*- Autoconf -*-

+

+# Copyright (C) 1997, 2000, 2001, 2003, 2004, 2005

+# Free Software Foundation, Inc.

+#

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# serial 7

+

+# AM_CONDITIONAL(NAME, SHELL-CONDITION)

+# -------------------------------------

+# Define a conditional.

+AC_DEFUN([AM_CONDITIONAL],

+[AC_PREREQ(2.52)dnl

+ ifelse([$1], [TRUE],  [AC_FATAL([$0: invalid condition: $1])],

+	[$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl

+AC_SUBST([$1_TRUE])

+AC_SUBST([$1_FALSE])

+if $2; then

+  $1_TRUE=

+  $1_FALSE='#'

+else

+  $1_TRUE='#'

+  $1_FALSE=

+fi

+AC_CONFIG_COMMANDS_PRE(

+[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then

+  AC_MSG_ERROR([[conditional "$1" was never defined.

+Usually this means the macro was only invoked conditionally.]])

+fi])])

+

+

+# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005

+# Free Software Foundation, Inc.

+#

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# serial 8

+

+# There are a few dirty hacks below to avoid letting `AC_PROG_CC' be

+# written in clear, in which case automake, when reading aclocal.m4,

+# will think it sees a *use*, and therefore will trigger all it's

+# C support machinery.  Also note that it means that autoscan, seeing

+# CC etc. in the Makefile, will ask for an AC_PROG_CC use...

+

+

+# _AM_DEPENDENCIES(NAME)

+# ----------------------

+# See how the compiler implements dependency checking.

+# NAME is "CC", "CXX", "GCJ", or "OBJC".

+# We try a few techniques and use that to set a single cache variable.

+#

+# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was

+# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular

+# dependency, and given that the user is not expected to run this macro,

+# just rely on AC_PROG_CC.

+AC_DEFUN([_AM_DEPENDENCIES],

+[AC_REQUIRE([AM_SET_DEPDIR])dnl

+AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl

+AC_REQUIRE([AM_MAKE_INCLUDE])dnl

+AC_REQUIRE([AM_DEP_TRACK])dnl

+

+ifelse([$1], CC,   [depcc="$CC"   am_compiler_list=],

+       [$1], CXX,  [depcc="$CXX"  am_compiler_list=],

+       [$1], OBJC, [depcc="$OBJC" am_compiler_list='gcc3 gcc'],

+       [$1], GCJ,  [depcc="$GCJ"  am_compiler_list='gcc3 gcc'],

+                   [depcc="$$1"   am_compiler_list=])

+

+AC_CACHE_CHECK([dependency style of $depcc],

+               [am_cv_$1_dependencies_compiler_type],

+[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then

+  # We make a subdir and do the tests there.  Otherwise we can end up

+  # making bogus files that we don't know about and never remove.  For

+  # instance it was reported that on HP-UX the gcc test will end up

+  # making a dummy file named `D' -- because `-MD' means `put the output

+  # in D'.

+  mkdir conftest.dir

+  # Copy depcomp to subdir because otherwise we won't find it if we're

+  # using a relative directory.

+  cp "$am_depcomp" conftest.dir

+  cd conftest.dir

+  # We will build objects and dependencies in a subdirectory because

+  # it helps to detect inapplicable dependency modes.  For instance

+  # both Tru64's cc and ICC support -MD to output dependencies as a

+  # side effect of compilation, but ICC will put the dependencies in

+  # the current directory while Tru64 will put them in the object

+  # directory.

+  mkdir sub

+

+  am_cv_$1_dependencies_compiler_type=none

+  if test "$am_compiler_list" = ""; then

+     am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp`

+  fi

+  for depmode in $am_compiler_list; do

+    # Setup a source with many dependencies, because some compilers

+    # like to wrap large dependency lists on column 80 (with \), and

+    # we should not choose a depcomp mode which is confused by this.

+    #

+    # We need to recreate these files for each test, as the compiler may

+    # overwrite some of them when testing with obscure command lines.

+    # This happens at least with the AIX C compiler.

+    : > sub/conftest.c

+    for i in 1 2 3 4 5 6; do

+      echo '#include "conftst'$i'.h"' >> sub/conftest.c

+      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with

+      # Solaris 8's {/usr,}/bin/sh.

+      touch sub/conftst$i.h

+    done

+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf

+

+    case $depmode in

+    nosideeffect)

+      # after this tag, mechanisms are not by side-effect, so they'll

+      # only be used when explicitly requested

+      if test "x$enable_dependency_tracking" = xyes; then

+	continue

+      else

+	break

+      fi

+      ;;

+    none) break ;;

+    esac

+    # We check with `-c' and `-o' for the sake of the "dashmstdout"

+    # mode.  It turns out that the SunPro C++ compiler does not properly

+    # handle `-M -o', and we need to detect this.

+    if depmode=$depmode \

+       source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \

+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \

+       $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \

+         >/dev/null 2>conftest.err &&

+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&

+       grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&

+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then

+      # icc doesn't choke on unknown options, it will just issue warnings

+      # or remarks (even with -Werror).  So we grep stderr for any message

+      # that says an option was ignored or not supported.

+      # When given -MP, icc 7.0 and 7.1 complain thusly:

+      #   icc: Command line warning: ignoring option '-M'; no argument required

+      # The diagnosis changed in icc 8.0:

+      #   icc: Command line remark: option '-MP' not supported

+      if (grep 'ignoring option' conftest.err ||

+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else

+        am_cv_$1_dependencies_compiler_type=$depmode

+        break

+      fi

+    fi

+  done

+

+  cd ..

+  rm -rf conftest.dir

+else

+  am_cv_$1_dependencies_compiler_type=none

+fi

+])

+AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type])

+AM_CONDITIONAL([am__fastdep$1], [

+  test "x$enable_dependency_tracking" != xno \

+  && test "$am_cv_$1_dependencies_compiler_type" = gcc3])

+])

+

+

+# AM_SET_DEPDIR

+# -------------

+# Choose a directory name for dependency files.

+# This macro is AC_REQUIREd in _AM_DEPENDENCIES

+AC_DEFUN([AM_SET_DEPDIR],

+[AC_REQUIRE([AM_SET_LEADING_DOT])dnl

+AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl

+])

+

+

+# AM_DEP_TRACK

+# ------------

+AC_DEFUN([AM_DEP_TRACK],

+[AC_ARG_ENABLE(dependency-tracking,

+[  --disable-dependency-tracking  speeds up one-time build

+  --enable-dependency-tracking   do not reject slow dependency extractors])

+if test "x$enable_dependency_tracking" != xno; then

+  am_depcomp="$ac_aux_dir/depcomp"

+  AMDEPBACKSLASH='\'

+fi

+AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])

+AC_SUBST([AMDEPBACKSLASH])

+])

+

+# Generate code to set up dependency tracking.              -*- Autoconf -*-

+

+# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005

+# Free Software Foundation, Inc.

+#

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+#serial 3

+

+# _AM_OUTPUT_DEPENDENCY_COMMANDS

+# ------------------------------

+AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],

+[for mf in $CONFIG_FILES; do

+  # Strip MF so we end up with the name of the file.

+  mf=`echo "$mf" | sed -e 's/:.*$//'`

+  # Check whether this is an Automake generated Makefile or not.

+  # We used to match only the files named `Makefile.in', but

+  # some people rename them; so instead we look at the file content.

+  # Grep'ing the first line is not enough: some people post-process

+  # each Makefile.in and add a new line on top of each file to say so.

+  # So let's grep whole file.

+  if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then

+    dirpart=`AS_DIRNAME("$mf")`

+  else

+    continue

+  fi

+  # Extract the definition of DEPDIR, am__include, and am__quote

+  # from the Makefile without running `make'.

+  DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`

+  test -z "$DEPDIR" && continue

+  am__include=`sed -n 's/^am__include = //p' < "$mf"`

+  test -z "am__include" && continue

+  am__quote=`sed -n 's/^am__quote = //p' < "$mf"`

+  # When using ansi2knr, U may be empty or an underscore; expand it

+  U=`sed -n 's/^U = //p' < "$mf"`

+  # Find all dependency output files, they are included files with

+  # $(DEPDIR) in their names.  We invoke sed twice because it is the

+  # simplest approach to changing $(DEPDIR) to its actual value in the

+  # expansion.

+  for file in `sed -n "

+    s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \

+       sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do

+    # Make sure the directory exists.

+    test -f "$dirpart/$file" && continue

+    fdir=`AS_DIRNAME(["$file"])`

+    AS_MKDIR_P([$dirpart/$fdir])

+    # echo "creating $dirpart/$file"

+    echo '# dummy' > "$dirpart/$file"

+  done

+done

+])# _AM_OUTPUT_DEPENDENCY_COMMANDS

+

+

+# AM_OUTPUT_DEPENDENCY_COMMANDS

+# -----------------------------

+# This macro should only be invoked once -- use via AC_REQUIRE.

+#

+# This code is only required when automatic dependency tracking

+# is enabled.  FIXME.  This creates each `.P' file that we will

+# need in order to bootstrap the dependency handling code.

+AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],

+[AC_CONFIG_COMMANDS([depfiles],

+     [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS],

+     [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"])

+])

+

+# Copyright (C) 1996, 1997, 2000, 2001, 2003, 2005

+# Free Software Foundation, Inc.

+#

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# serial 8

+

+# AM_CONFIG_HEADER is obsolete.  It has been replaced by AC_CONFIG_HEADERS.

+AU_DEFUN([AM_CONFIG_HEADER], [AC_CONFIG_HEADERS($@)])

+

+# Do all the work for Automake.                             -*- Autoconf -*-

+

+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005

+# Free Software Foundation, Inc.

+#

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# serial 12

+

+# This macro actually does too much.  Some checks are only needed if

+# your package does certain things.  But this isn't really a big deal.

+

+# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])

+# AM_INIT_AUTOMAKE([OPTIONS])

+# -----------------------------------------------

+# The call with PACKAGE and VERSION arguments is the old style

+# call (pre autoconf-2.50), which is being phased out.  PACKAGE

+# and VERSION should now be passed to AC_INIT and removed from

+# the call to AM_INIT_AUTOMAKE.

+# We support both call styles for the transition.  After

+# the next Automake release, Autoconf can make the AC_INIT

+# arguments mandatory, and then we can depend on a new Autoconf

+# release and drop the old call support.

+AC_DEFUN([AM_INIT_AUTOMAKE],

+[AC_PREREQ([2.58])dnl

+dnl Autoconf wants to disallow AM_ names.  We explicitly allow

+dnl the ones we care about.

+m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl

+AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl

+AC_REQUIRE([AC_PROG_INSTALL])dnl

+# test to see if srcdir already configured

+if test "`cd $srcdir && pwd`" != "`pwd`" &&

+   test -f $srcdir/config.status; then

+  AC_MSG_ERROR([source directory already configured; run "make distclean" there first])

+fi

+

+# test whether we have cygpath

+if test -z "$CYGPATH_W"; then

+  if (cygpath --version) >/dev/null 2>/dev/null; then

+    CYGPATH_W='cygpath -w'

+  else

+    CYGPATH_W=echo

+  fi

+fi

+AC_SUBST([CYGPATH_W])

+

+# Define the identity of the package.

+dnl Distinguish between old-style and new-style calls.

+m4_ifval([$2],

+[m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl

+ AC_SUBST([PACKAGE], [$1])dnl

+ AC_SUBST([VERSION], [$2])],

+[_AM_SET_OPTIONS([$1])dnl

+ AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl

+ AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl

+

+_AM_IF_OPTION([no-define],,

+[AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])

+ AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package])])dnl

+

+# Some tools Automake needs.

+AC_REQUIRE([AM_SANITY_CHECK])dnl

+AC_REQUIRE([AC_ARG_PROGRAM])dnl

+AM_MISSING_PROG(ACLOCAL, aclocal-${am__api_version})

+AM_MISSING_PROG(AUTOCONF, autoconf)

+AM_MISSING_PROG(AUTOMAKE, automake-${am__api_version})

+AM_MISSING_PROG(AUTOHEADER, autoheader)

+AM_MISSING_PROG(MAKEINFO, makeinfo)

+AM_PROG_INSTALL_SH

+AM_PROG_INSTALL_STRIP

+AC_REQUIRE([AM_PROG_MKDIR_P])dnl

+# We need awk for the "check" target.  The system "awk" is bad on

+# some platforms.

+AC_REQUIRE([AC_PROG_AWK])dnl

+AC_REQUIRE([AC_PROG_MAKE_SET])dnl

+AC_REQUIRE([AM_SET_LEADING_DOT])dnl

+_AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])],

+              [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])],

+	      		     [_AM_PROG_TAR([v7])])])

+_AM_IF_OPTION([no-dependencies],,

+[AC_PROVIDE_IFELSE([AC_PROG_CC],

+                  [_AM_DEPENDENCIES(CC)],

+                  [define([AC_PROG_CC],

+                          defn([AC_PROG_CC])[_AM_DEPENDENCIES(CC)])])dnl

+AC_PROVIDE_IFELSE([AC_PROG_CXX],

+                  [_AM_DEPENDENCIES(CXX)],

+                  [define([AC_PROG_CXX],

+                          defn([AC_PROG_CXX])[_AM_DEPENDENCIES(CXX)])])dnl

+])

+])

+

+

+# When config.status generates a header, we must update the stamp-h file.

+# This file resides in the same directory as the config header

+# that is generated.  The stamp files are numbered to have different names.

+

+# Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the

+# loop where config.status creates the headers, so we can generate

+# our stamp files there.

+AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK],

+[# Compute $1's index in $config_headers.

+_am_stamp_count=1

+for _am_header in $config_headers :; do

+  case $_am_header in

+    $1 | $1:* )

+      break ;;

+    * )

+      _am_stamp_count=`expr $_am_stamp_count + 1` ;;

+  esac

+done

+echo "timestamp for $1" >`AS_DIRNAME([$1])`/stamp-h[]$_am_stamp_count])

+

+# Copyright (C) 2001, 2003, 2005  Free Software Foundation, Inc.

+#

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# AM_PROG_INSTALL_SH

+# ------------------

+# Define $install_sh.

+AC_DEFUN([AM_PROG_INSTALL_SH],

+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl

+install_sh=${install_sh-"$am_aux_dir/install-sh"}

+AC_SUBST(install_sh)])

+

+# Copyright (C) 2003, 2005  Free Software Foundation, Inc.

+#

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# serial 2

+

+# Check whether the underlying file-system supports filenames

+# with a leading dot.  For instance MS-DOS doesn't.

+AC_DEFUN([AM_SET_LEADING_DOT],

+[rm -rf .tst 2>/dev/null

+mkdir .tst 2>/dev/null

+if test -d .tst; then

+  am__leading_dot=.

+else

+  am__leading_dot=_

+fi

+rmdir .tst 2>/dev/null

+AC_SUBST([am__leading_dot])])

+

+# Check to see how 'make' treats includes.	            -*- Autoconf -*-

+

+# Copyright (C) 2001, 2002, 2003, 2005  Free Software Foundation, Inc.

+#

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# serial 3

+

+# AM_MAKE_INCLUDE()

+# -----------------

+# Check to see how make treats includes.

+AC_DEFUN([AM_MAKE_INCLUDE],

+[am_make=${MAKE-make}

+cat > confinc << 'END'

+am__doit:

+	@echo done

+.PHONY: am__doit

+END

+# If we don't find an include directive, just comment out the code.

+AC_MSG_CHECKING([for style of include used by $am_make])

+am__include="#"

+am__quote=

+_am_result=none

+# First try GNU make style include.

+echo "include confinc" > confmf

+# We grep out `Entering directory' and `Leaving directory'

+# messages which can occur if `w' ends up in MAKEFLAGS.

+# In particular we don't look at `^make:' because GNU make might

+# be invoked under some other name (usually "gmake"), in which

+# case it prints its new name instead of `make'.

+if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then

+   am__include=include

+   am__quote=

+   _am_result=GNU

+fi

+# Now try BSD make style include.

+if test "$am__include" = "#"; then

+   echo '.include "confinc"' > confmf

+   if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then

+      am__include=.include

+      am__quote="\""

+      _am_result=BSD

+   fi

+fi

+AC_SUBST([am__include])

+AC_SUBST([am__quote])

+AC_MSG_RESULT([$_am_result])

+rm -f confinc confmf

+])

+

+# Fake the existence of programs that GNU maintainers use.  -*- Autoconf -*-

+

+# Copyright (C) 1997, 1999, 2000, 2001, 2003, 2005

+# Free Software Foundation, Inc.

+#

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# serial 4

+

+# AM_MISSING_PROG(NAME, PROGRAM)

+# ------------------------------

+AC_DEFUN([AM_MISSING_PROG],

+[AC_REQUIRE([AM_MISSING_HAS_RUN])

+$1=${$1-"${am_missing_run}$2"}

+AC_SUBST($1)])

+

+

+# AM_MISSING_HAS_RUN

+# ------------------

+# Define MISSING if not defined so far and test if it supports --run.

+# If it does, set am_missing_run to use it, otherwise, to nothing.

+AC_DEFUN([AM_MISSING_HAS_RUN],

+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl

+test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing"

+# Use eval to expand $SHELL

+if eval "$MISSING --run true"; then

+  am_missing_run="$MISSING --run "

+else

+  am_missing_run=

+  AC_MSG_WARN([`missing' script is too old or missing])

+fi

+])

+

+# Copyright (C) 2003, 2004, 2005  Free Software Foundation, Inc.

+#

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# AM_PROG_MKDIR_P

+# ---------------

+# Check whether `mkdir -p' is supported, fallback to mkinstalldirs otherwise.

+#

+# Automake 1.8 used `mkdir -m 0755 -p --' to ensure that directories

+# created by `make install' are always world readable, even if the

+# installer happens to have an overly restrictive umask (e.g. 077).

+# This was a mistake.  There are at least two reasons why we must not

+# use `-m 0755':

+#   - it causes special bits like SGID to be ignored,

+#   - it may be too restrictive (some setups expect 775 directories).

+#

+# Do not use -m 0755 and let people choose whatever they expect by

+# setting umask.

+#

+# We cannot accept any implementation of `mkdir' that recognizes `-p'.

+# Some implementations (such as Solaris 8's) are not thread-safe: if a

+# parallel make tries to run `mkdir -p a/b' and `mkdir -p a/c'

+# concurrently, both version can detect that a/ is missing, but only

+# one can create it and the other will error out.  Consequently we

+# restrict ourselves to GNU make (using the --version option ensures

+# this.)

+AC_DEFUN([AM_PROG_MKDIR_P],

+[if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then

+  # We used to keeping the `.' as first argument, in order to

+  # allow $(mkdir_p) to be used without argument.  As in

+  #   $(mkdir_p) $(somedir)

+  # where $(somedir) is conditionally defined.  However this is wrong

+  # for two reasons:

+  #  1. if the package is installed by a user who cannot write `.'

+  #     make install will fail,

+  #  2. the above comment should most certainly read

+  #     $(mkdir_p) $(DESTDIR)$(somedir)

+  #     so it does not work when $(somedir) is undefined and

+  #     $(DESTDIR) is not.

+  #  To support the latter case, we have to write

+  #     test -z "$(somedir)" || $(mkdir_p) $(DESTDIR)$(somedir),

+  #  so the `.' trick is pointless.

+  mkdir_p='mkdir -p --'

+else

+  # On NextStep and OpenStep, the `mkdir' command does not

+  # recognize any option.  It will interpret all options as

+  # directories to create, and then abort because `.' already

+  # exists.

+  for d in ./-p ./--version;

+  do

+    test -d $d && rmdir $d

+  done

+  # $(mkinstalldirs) is defined by Automake if mkinstalldirs exists.

+  if test -f "$ac_aux_dir/mkinstalldirs"; then

+    mkdir_p='$(mkinstalldirs)'

+  else

+    mkdir_p='$(install_sh) -d'

+  fi

+fi

+AC_SUBST([mkdir_p])])

+

+# Helper functions for option handling.                     -*- Autoconf -*-

+

+# Copyright (C) 2001, 2002, 2003, 2005  Free Software Foundation, Inc.

+#

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# serial 3

+

+# _AM_MANGLE_OPTION(NAME)

+# -----------------------

+AC_DEFUN([_AM_MANGLE_OPTION],

+[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])

+

+# _AM_SET_OPTION(NAME)

+# ------------------------------

+# Set option NAME.  Presently that only means defining a flag for this option.

+AC_DEFUN([_AM_SET_OPTION],

+[m4_define(_AM_MANGLE_OPTION([$1]), 1)])

+

+# _AM_SET_OPTIONS(OPTIONS)

+# ----------------------------------

+# OPTIONS is a space-separated list of Automake options.

+AC_DEFUN([_AM_SET_OPTIONS],

+[AC_FOREACH([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])])

+

+# _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])

+# -------------------------------------------

+# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.

+AC_DEFUN([_AM_IF_OPTION],

+[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])

+

+# Check to make sure that the build environment is sane.    -*- Autoconf -*-

+

+# Copyright (C) 1996, 1997, 2000, 2001, 2003, 2005

+# Free Software Foundation, Inc.

+#

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# serial 4

+

+# AM_SANITY_CHECK

+# ---------------

+AC_DEFUN([AM_SANITY_CHECK],

+[AC_MSG_CHECKING([whether build environment is sane])

+# Just in case

+sleep 1

+echo timestamp > conftest.file

+# Do `set' in a subshell so we don't clobber the current shell's

+# arguments.  Must try -L first in case configure is actually a

+# symlink; some systems play weird games with the mod time of symlinks

+# (eg FreeBSD returns the mod time of the symlink's containing

+# directory).

+if (

+   set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null`

+   if test "$[*]" = "X"; then

+      # -L didn't work.

+      set X `ls -t $srcdir/configure conftest.file`

+   fi

+   rm -f conftest.file

+   if test "$[*]" != "X $srcdir/configure conftest.file" \

+      && test "$[*]" != "X conftest.file $srcdir/configure"; then

+

+      # If neither matched, then we have a broken ls.  This can happen

+      # if, for instance, CONFIG_SHELL is bash and it inherits a

+      # broken ls alias from the environment.  This has actually

+      # happened.  Such a system could not be considered "sane".

+      AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken

+alias in your environment])

+   fi

+

+   test "$[2]" = conftest.file

+   )

+then

+   # Ok.

+   :

+else

+   AC_MSG_ERROR([newly created file is older than distributed files!

+Check your system clock])

+fi

+AC_MSG_RESULT(yes)])

+

+# Copyright (C) 2001, 2003, 2005  Free Software Foundation, Inc.

+#

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# AM_PROG_INSTALL_STRIP

+# ---------------------

+# One issue with vendor `install' (even GNU) is that you can't

+# specify the program used to strip binaries.  This is especially

+# annoying in cross-compiling environments, where the build's strip

+# is unlikely to handle the host's binaries.

+# Fortunately install-sh will honor a STRIPPROG variable, so we

+# always use install-sh in `make install-strip', and initialize

+# STRIPPROG with the value of the STRIP variable (set by the user).

+AC_DEFUN([AM_PROG_INSTALL_STRIP],

+[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl

+# Installed binaries are usually stripped using `strip' when the user

+# run `make install-strip'.  However `strip' might not be the right

+# tool to use in cross-compilation environments, therefore Automake

+# will honor the `STRIP' environment variable to overrule this program.

+dnl Don't test for $cross_compiling = yes, because it might be `maybe'.

+if test "$cross_compiling" != no; then

+  AC_CHECK_TOOL([STRIP], [strip], :)

+fi

+INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s"

+AC_SUBST([INSTALL_STRIP_PROGRAM])])

+

+# Check how to create a tarball.                            -*- Autoconf -*-

+

+# Copyright (C) 2004, 2005  Free Software Foundation, Inc.

+#

+# This file is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# serial 2

+

+# _AM_PROG_TAR(FORMAT)

+# --------------------

+# Check how to create a tarball in format FORMAT.

+# FORMAT should be one of `v7', `ustar', or `pax'.

+#

+# Substitute a variable $(am__tar) that is a command

+# writing to stdout a FORMAT-tarball containing the directory

+# $tardir.

+#     tardir=directory && $(am__tar) > result.tar

+#

+# Substitute a variable $(am__untar) that extract such

+# a tarball read from stdin.

+#     $(am__untar) < result.tar

+AC_DEFUN([_AM_PROG_TAR],

+[# Always define AMTAR for backward compatibility.

+AM_MISSING_PROG([AMTAR], [tar])

+m4_if([$1], [v7],

+     [am__tar='${AMTAR} chof - "$$tardir"'; am__untar='${AMTAR} xf -'],

+     [m4_case([$1], [ustar],, [pax],,

+              [m4_fatal([Unknown tar format])])

+AC_MSG_CHECKING([how to create a $1 tar archive])

+# Loop over all known methods to create a tar archive until one works.

+_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'

+_am_tools=${am_cv_prog_tar_$1-$_am_tools}

+# Do not fold the above two line into one, because Tru64 sh and

+# Solaris sh will not grok spaces in the rhs of `-'.

+for _am_tool in $_am_tools

+do

+  case $_am_tool in

+  gnutar)

+    for _am_tar in tar gnutar gtar;

+    do

+      AM_RUN_LOG([$_am_tar --version]) && break

+    done

+    am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'

+    am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'

+    am__untar="$_am_tar -xf -"

+    ;;

+  plaintar)

+    # Must skip GNU tar: if it does not support --format= it doesn't create

+    # ustar tarball either.

+    (tar --version) >/dev/null 2>&1 && continue

+    am__tar='tar chf - "$$tardir"'

+    am__tar_='tar chf - "$tardir"'

+    am__untar='tar xf -'

+    ;;

+  pax)

+    am__tar='pax -L -x $1 -w "$$tardir"'

+    am__tar_='pax -L -x $1 -w "$tardir"'

+    am__untar='pax -r'

+    ;;

+  cpio)

+    am__tar='find "$$tardir" -print | cpio -o -H $1 -L'

+    am__tar_='find "$tardir" -print | cpio -o -H $1 -L'

+    am__untar='cpio -i -H $1 -d'

+    ;;

+  none)

+    am__tar=false

+    am__tar_=false

+    am__untar=false

+    ;;

+  esac

+

+  # If the value was cached, stop now.  We just wanted to have am__tar

+  # and am__untar set.

+  test -n "${am_cv_prog_tar_$1}" && break

+

+  # tar/untar a dummy directory, and stop if the command works

+  rm -rf conftest.dir

+  mkdir conftest.dir

+  echo GrepMe > conftest.dir/file

+  AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])

+  rm -rf conftest.dir

+  if test -s conftest.tar; then

+    AM_RUN_LOG([$am__untar <conftest.tar])

+    grep GrepMe conftest.dir/file >/dev/null 2>&1 && break

+  fi

+done

+rm -rf conftest.dir

+

+AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])

+AC_MSG_RESULT([$am_cv_prog_tar_$1])])

+AC_SUBST([am__tar])

+AC_SUBST([am__untar])

+]) # _AM_PROG_TAR

+

+m4_include([m4/ac_have_attribute.m4])

+m4_include([m4/acx_pthread.m4])

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/autogen.sh b/sdch/open_vcdiff/depot/opensource/open-vcdiff/autogen.sh
new file mode 100755
index 0000000..461efee
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/autogen.sh
@@ -0,0 +1,51 @@
+#!/bin/sh
+
+# These are the files that this script might edit:
+#    aclocal.m4 configure Makefile.in src/config.h.in \
+#    depcomp config.guess config.sub install-sh missing mkinstalldirs \
+#    ltmain.sh
+#
+# Here's a command you can run to see what files aclocal will import:
+#  aclocal -I ../autoconf --output=- | sed -n 's/^m4_include..\([^]]*\).*/\1/p'
+
+set -ex
+rm -rf autom4te.cache
+
+trap 'rm -f aclocal.m4.tmp' EXIT
+
+# Use version 1.9 of aclocal and automake if available.
+ACLOCAL=aclocal-1.9
+if test -z `which "$ACLOCAL"`; then
+  ACLOCAL=aclocal
+fi
+
+AUTOMAKE=automake-1.9
+if test -z `which "$AUTOMAKE"`; then
+  AUTOMAKE=automake
+fi
+
+# glibtoolize is used for Mac OS X
+LIBTOOLIZE=libtoolize
+if test -z `which "$LIBTOOLIZE"`; then
+  LIBTOOLIZE=glibtoolize
+fi
+
+# aclocal tries to overwrite aclocal.m4 even if the contents haven't
+# changed, which is annoying when the file is not open for edit (in
+# p4).  We work around this by writing to a temp file and just
+# updating the timestamp if the file hasn't change.
+"$ACLOCAL" --force -I m4 --output=aclocal.m4.tmp
+if cmp aclocal.m4.tmp aclocal.m4; then
+  touch aclocal.m4               # pretend that we regenerated the file
+  rm -f aclocal.m4.tmp
+else
+  mv aclocal.m4.tmp aclocal.m4   # we did set -e above, so we die if this fails
+fi
+
+grep -q LIBTOOL configure.ac && "$LIBTOOLIZE" -c -f
+autoconf -f -W all,no-obsolete
+autoheader -f -W all
+"$AUTOMAKE" -a -c -f -W all
+
+rm -rf autom4te.cache
+exit 0
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/compile b/sdch/open_vcdiff/depot/opensource/open-vcdiff/compile
new file mode 100644
index 0000000..954489a
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/compile
@@ -0,0 +1,99 @@
+#! /bin/sh

+

+# Wrapper for compilers which do not understand `-c -o'.

+

+# Copyright 1999, 2000 Free Software Foundation, Inc.

+# Written by Tom Tromey <tromey@cygnus.com>.

+#

+# This program is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published by

+# the Free Software Foundation; either version 2, or (at your option)

+# any later version.

+#

+# This program is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with this program; if not, write to the Free Software

+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

+

+# As a special exception to the GNU General Public License, if you

+# distribute this file as part of a program that contains a

+# configuration script generated by Autoconf, you may include it under

+# the same distribution terms that you use for the rest of that program.

+

+# Usage:

+# compile PROGRAM [ARGS]...

+# `-o FOO.o' is removed from the args passed to the actual compile.

+

+prog=$1

+shift

+

+ofile=

+cfile=

+args=

+while test $# -gt 0; do

+   case "$1" in

+    -o)

+       # configure might choose to run compile as `compile cc -o foo foo.c'.

+       # So we do something ugly here.

+       ofile=$2

+       shift

+       case "$ofile" in

+	*.o | *.obj)

+	   ;;

+	*)

+	   args="$args -o $ofile"

+	   ofile=

+	   ;;

+       esac

+       ;;

+    *.c)

+       cfile=$1

+       args="$args $1"

+       ;;

+    *)

+       args="$args $1"

+       ;;

+   esac

+   shift

+done

+

+if test -z "$ofile" || test -z "$cfile"; then

+   # If no `-o' option was seen then we might have been invoked from a

+   # pattern rule where we don't need one.  That is ok -- this is a

+   # normal compilation that the losing compiler can handle.  If no

+   # `.c' file was seen then we are probably linking.  That is also

+   # ok.

+   exec "$prog" $args

+fi

+

+# Name of file we expect compiler to create.

+cofile=`echo $cfile | sed -e 's|^.*/||' -e 's/\.c$/.o/'`

+

+# Create the lock directory.

+# Note: use `[/.-]' here to ensure that we don't use the same name

+# that we are using for the .o file.  Also, base the name on the expected

+# object file name, since that is what matters with a parallel build.

+lockdir=`echo $cofile | sed -e 's|[/.-]|_|g'`.d

+while true; do

+   if mkdir $lockdir > /dev/null 2>&1; then

+      break

+   fi

+   sleep 1

+done

+# FIXME: race condition here if user kills between mkdir and trap.

+trap "rmdir $lockdir; exit 1" 1 2 15

+

+# Run the compile.

+"$prog" $args

+status=$?

+

+if test -f "$cofile"; then

+   mv "$cofile" "$ofile"

+fi

+

+rmdir $lockdir

+exit $status

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/config.guess b/sdch/open_vcdiff/depot/opensource/open-vcdiff/config.guess
new file mode 100644
index 0000000..3123c7e
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/config.guess
@@ -0,0 +1,1466 @@
+#! /bin/sh

+# Attempt to guess a canonical system name.

+#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,

+#   2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.

+

+timestamp='2005-08-03'

+

+# This file is free software; you can redistribute it and/or modify it

+# under the terms of the GNU General Public License as published by

+# the Free Software Foundation; either version 2 of the License, or

+# (at your option) any later version.

+#

+# This program is distributed in the hope that it will be useful, but

+# WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+# General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with this program; if not, write to the Free Software

+# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA

+# 02110-1301, USA.

+#

+# As a special exception to the GNU General Public License, if you

+# distribute this file as part of a program that contains a

+# configuration script generated by Autoconf, you may include it under

+# the same distribution terms that you use for the rest of that program.

+

+

+# Originally written by Per Bothner <per@bothner.com>.

+# Please send patches to <config-patches@gnu.org>.  Submit a context

+# diff and a properly formatted ChangeLog entry.

+#

+# This script attempts to guess a canonical system name similar to

+# config.sub.  If it succeeds, it prints the system name on stdout, and

+# exits with 0.  Otherwise, it exits with 1.

+#

+# The plan is that this can be called by configure scripts if you

+# don't specify an explicit build system type.

+

+me=`echo "$0" | sed -e 's,.*/,,'`

+

+usage="\

+Usage: $0 [OPTION]

+

+Output the configuration name of the system \`$me' is run on.

+

+Operation modes:

+  -h, --help         print this help, then exit

+  -t, --time-stamp   print date of last modification, then exit

+  -v, --version      print version number, then exit

+

+Report bugs and patches to <config-patches@gnu.org>."

+

+version="\

+GNU config.guess ($timestamp)

+

+Originally written by Per Bothner.

+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005

+Free Software Foundation, Inc.

+

+This is free software; see the source for copying conditions.  There is NO

+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."

+

+help="

+Try \`$me --help' for more information."

+

+# Parse command line

+while test $# -gt 0 ; do

+  case $1 in

+    --time-stamp | --time* | -t )

+       echo "$timestamp" ; exit ;;

+    --version | -v )

+       echo "$version" ; exit ;;

+    --help | --h* | -h )

+       echo "$usage"; exit ;;

+    -- )     # Stop option processing

+       shift; break ;;

+    - )	# Use stdin as input.

+       break ;;

+    -* )

+       echo "$me: invalid option $1$help" >&2

+       exit 1 ;;

+    * )

+       break ;;

+  esac

+done

+

+if test $# != 0; then

+  echo "$me: too many arguments$help" >&2

+  exit 1

+fi

+

+trap 'exit 1' 1 2 15

+

+# CC_FOR_BUILD -- compiler used by this script. Note that the use of a

+# compiler to aid in system detection is discouraged as it requires

+# temporary files to be created and, as you can see below, it is a

+# headache to deal with in a portable fashion.

+

+# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still

+# use `HOST_CC' if defined, but it is deprecated.

+

+# Portable tmp directory creation inspired by the Autoconf team.

+

+set_cc_for_build='

+trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;

+trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;

+: ${TMPDIR=/tmp} ;

+ { tmp=`(umask 077 && mktemp -d -q "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||

+ { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||

+ { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||

+ { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;

+dummy=$tmp/dummy ;

+tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;

+case $CC_FOR_BUILD,$HOST_CC,$CC in

+ ,,)    echo "int x;" > $dummy.c ;

+	for c in cc gcc c89 c99 ; do

+	  if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then

+	     CC_FOR_BUILD="$c"; break ;

+	  fi ;

+	done ;

+	if test x"$CC_FOR_BUILD" = x ; then

+	  CC_FOR_BUILD=no_compiler_found ;

+	fi

+	;;

+ ,,*)   CC_FOR_BUILD=$CC ;;

+ ,*,*)  CC_FOR_BUILD=$HOST_CC ;;

+esac ; set_cc_for_build= ;'

+

+# This is needed to find uname on a Pyramid OSx when run in the BSD universe.

+# (ghazi@noc.rutgers.edu 1994-08-24)

+if (test -f /.attbin/uname) >/dev/null 2>&1 ; then

+	PATH=$PATH:/.attbin ; export PATH

+fi

+

+UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown

+UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown

+UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown

+UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown

+

+# Note: order is significant - the case branches are not exclusive.

+

+case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in

+    *:NetBSD:*:*)

+	# NetBSD (nbsd) targets should (where applicable) match one or

+	# more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*,

+	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently

+	# switched to ELF, *-*-netbsd* would select the old

+	# object file format.  This provides both forward

+	# compatibility and a consistent mechanism for selecting the

+	# object file format.

+	#

+	# Note: NetBSD doesn't particularly care about the vendor

+	# portion of the name.  We always set it to "unknown".

+	sysctl="sysctl -n hw.machine_arch"

+	UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \

+	    /usr/sbin/$sysctl 2>/dev/null || echo unknown)`

+	case "${UNAME_MACHINE_ARCH}" in

+	    armeb) machine=armeb-unknown ;;

+	    arm*) machine=arm-unknown ;;

+	    sh3el) machine=shl-unknown ;;

+	    sh3eb) machine=sh-unknown ;;

+	    *) machine=${UNAME_MACHINE_ARCH}-unknown ;;

+	esac

+	# The Operating System including object format, if it has switched

+	# to ELF recently, or will in the future.

+	case "${UNAME_MACHINE_ARCH}" in

+	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)

+		eval $set_cc_for_build

+		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \

+			| grep __ELF__ >/dev/null

+		then

+		    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).

+		    # Return netbsd for either.  FIX?

+		    os=netbsd

+		else

+		    os=netbsdelf

+		fi

+		;;

+	    *)

+	        os=netbsd

+		;;

+	esac

+	# The OS release

+	# Debian GNU/NetBSD machines have a different userland, and

+	# thus, need a distinct triplet. However, they do not need

+	# kernel version information, so it can be replaced with a

+	# suitable tag, in the style of linux-gnu.

+	case "${UNAME_VERSION}" in

+	    Debian*)

+		release='-gnu'

+		;;

+	    *)

+		release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`

+		;;

+	esac

+	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:

+	# contains redundant information, the shorter form:

+	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.

+	echo "${machine}-${os}${release}"

+	exit ;;

+    *:OpenBSD:*:*)

+	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`

+	echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}

+	exit ;;

+    *:ekkoBSD:*:*)

+	echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}

+	exit ;;

+    macppc:MirBSD:*:*)

+	echo powerppc-unknown-mirbsd${UNAME_RELEASE}

+	exit ;;

+    *:MirBSD:*:*)

+	echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}

+	exit ;;

+    alpha:OSF1:*:*)

+	case $UNAME_RELEASE in

+	*4.0)

+		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`

+		;;

+	*5.*)

+	        UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`

+		;;

+	esac

+	# According to Compaq, /usr/sbin/psrinfo has been available on

+	# OSF/1 and Tru64 systems produced since 1995.  I hope that

+	# covers most systems running today.  This code pipes the CPU

+	# types through head -n 1, so we only detect the type of CPU 0.

+	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1`

+	case "$ALPHA_CPU_TYPE" in

+	    "EV4 (21064)")

+		UNAME_MACHINE="alpha" ;;

+	    "EV4.5 (21064)")

+		UNAME_MACHINE="alpha" ;;

+	    "LCA4 (21066/21068)")

+		UNAME_MACHINE="alpha" ;;

+	    "EV5 (21164)")

+		UNAME_MACHINE="alphaev5" ;;

+	    "EV5.6 (21164A)")

+		UNAME_MACHINE="alphaev56" ;;

+	    "EV5.6 (21164PC)")

+		UNAME_MACHINE="alphapca56" ;;

+	    "EV5.7 (21164PC)")

+		UNAME_MACHINE="alphapca57" ;;

+	    "EV6 (21264)")

+		UNAME_MACHINE="alphaev6" ;;

+	    "EV6.7 (21264A)")

+		UNAME_MACHINE="alphaev67" ;;

+	    "EV6.8CB (21264C)")

+		UNAME_MACHINE="alphaev68" ;;

+	    "EV6.8AL (21264B)")

+		UNAME_MACHINE="alphaev68" ;;

+	    "EV6.8CX (21264D)")

+		UNAME_MACHINE="alphaev68" ;;

+	    "EV6.9A (21264/EV69A)")

+		UNAME_MACHINE="alphaev69" ;;

+	    "EV7 (21364)")

+		UNAME_MACHINE="alphaev7" ;;

+	    "EV7.9 (21364A)")

+		UNAME_MACHINE="alphaev79" ;;

+	esac

+	# A Pn.n version is a patched version.

+	# A Vn.n version is a released version.

+	# A Tn.n version is a released field test version.

+	# A Xn.n version is an unreleased experimental baselevel.

+	# 1.2 uses "1.2" for uname -r.

+	echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`

+	exit ;;

+    Alpha\ *:Windows_NT*:*)

+	# How do we know it's Interix rather than the generic POSIX subsystem?

+	# Should we change UNAME_MACHINE based on the output of uname instead

+	# of the specific Alpha model?

+	echo alpha-pc-interix

+	exit ;;

+    21064:Windows_NT:50:3)

+	echo alpha-dec-winnt3.5

+	exit ;;

+    Amiga*:UNIX_System_V:4.0:*)

+	echo m68k-unknown-sysv4

+	exit ;;

+    *:[Aa]miga[Oo][Ss]:*:*)

+	echo ${UNAME_MACHINE}-unknown-amigaos

+	exit ;;

+    *:[Mm]orph[Oo][Ss]:*:*)

+	echo ${UNAME_MACHINE}-unknown-morphos

+	exit ;;

+    *:OS/390:*:*)

+	echo i370-ibm-openedition

+	exit ;;

+    *:z/VM:*:*)

+	echo s390-ibm-zvmoe

+	exit ;;

+    *:OS400:*:*)

+        echo powerpc-ibm-os400

+	exit ;;

+    arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)

+	echo arm-acorn-riscix${UNAME_RELEASE}

+	exit ;;

+    arm:riscos:*:*|arm:RISCOS:*:*)

+	echo arm-unknown-riscos

+	exit ;;

+    SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)

+	echo hppa1.1-hitachi-hiuxmpp

+	exit ;;

+    Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)

+	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.

+	if test "`(/bin/universe) 2>/dev/null`" = att ; then

+		echo pyramid-pyramid-sysv3

+	else

+		echo pyramid-pyramid-bsd

+	fi

+	exit ;;

+    NILE*:*:*:dcosx)

+	echo pyramid-pyramid-svr4

+	exit ;;

+    DRS?6000:unix:4.0:6*)

+	echo sparc-icl-nx6

+	exit ;;

+    DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)

+	case `/usr/bin/uname -p` in

+	    sparc) echo sparc-icl-nx7; exit ;;

+	esac ;;

+    sun4H:SunOS:5.*:*)

+	echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`

+	exit ;;

+    sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)

+	echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`

+	exit ;;

+    i86pc:SunOS:5.*:*)

+	echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`

+	exit ;;

+    sun4*:SunOS:6*:*)

+	# According to config.sub, this is the proper way to canonicalize

+	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but

+	# it's likely to be more like Solaris than SunOS4.

+	echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`

+	exit ;;

+    sun4*:SunOS:*:*)

+	case "`/usr/bin/arch -k`" in

+	    Series*|S4*)

+		UNAME_RELEASE=`uname -v`

+		;;

+	esac

+	# Japanese Language versions have a version number like `4.1.3-JL'.

+	echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`

+	exit ;;

+    sun3*:SunOS:*:*)

+	echo m68k-sun-sunos${UNAME_RELEASE}

+	exit ;;

+    sun*:*:4.2BSD:*)

+	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`

+	test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3

+	case "`/bin/arch`" in

+	    sun3)

+		echo m68k-sun-sunos${UNAME_RELEASE}

+		;;

+	    sun4)

+		echo sparc-sun-sunos${UNAME_RELEASE}

+		;;

+	esac

+	exit ;;

+    aushp:SunOS:*:*)

+	echo sparc-auspex-sunos${UNAME_RELEASE}

+	exit ;;

+    # The situation for MiNT is a little confusing.  The machine name

+    # can be virtually everything (everything which is not

+    # "atarist" or "atariste" at least should have a processor

+    # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"

+    # to the lowercase version "mint" (or "freemint").  Finally

+    # the system name "TOS" denotes a system which is actually not

+    # MiNT.  But MiNT is downward compatible to TOS, so this should

+    # be no problem.

+    atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)

+        echo m68k-atari-mint${UNAME_RELEASE}

+	exit ;;

+    atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)

+	echo m68k-atari-mint${UNAME_RELEASE}

+        exit ;;

+    *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)

+        echo m68k-atari-mint${UNAME_RELEASE}

+	exit ;;

+    milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)

+        echo m68k-milan-mint${UNAME_RELEASE}

+        exit ;;

+    hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)

+        echo m68k-hades-mint${UNAME_RELEASE}

+        exit ;;

+    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)

+        echo m68k-unknown-mint${UNAME_RELEASE}

+        exit ;;

+    m68k:machten:*:*)

+	echo m68k-apple-machten${UNAME_RELEASE}

+	exit ;;

+    powerpc:machten:*:*)

+	echo powerpc-apple-machten${UNAME_RELEASE}

+	exit ;;

+    RISC*:Mach:*:*)

+	echo mips-dec-mach_bsd4.3

+	exit ;;

+    RISC*:ULTRIX:*:*)

+	echo mips-dec-ultrix${UNAME_RELEASE}

+	exit ;;

+    VAX*:ULTRIX*:*:*)

+	echo vax-dec-ultrix${UNAME_RELEASE}

+	exit ;;

+    2020:CLIX:*:* | 2430:CLIX:*:*)

+	echo clipper-intergraph-clix${UNAME_RELEASE}

+	exit ;;

+    mips:*:*:UMIPS | mips:*:*:RISCos)

+	eval $set_cc_for_build

+	sed 's/^	//' << EOF >$dummy.c

+#ifdef __cplusplus

+#include <stdio.h>  /* for printf() prototype */

+	int main (int argc, char *argv[]) {

+#else

+	int main (argc, argv) int argc; char *argv[]; {

+#endif

+	#if defined (host_mips) && defined (MIPSEB)

+	#if defined (SYSTYPE_SYSV)

+	  printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);

+	#endif

+	#if defined (SYSTYPE_SVR4)

+	  printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);

+	#endif

+	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)

+	  printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);

+	#endif

+	#endif

+	  exit (-1);

+	}

+EOF

+	$CC_FOR_BUILD -o $dummy $dummy.c &&

+	  dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` &&

+	  SYSTEM_NAME=`$dummy $dummyarg` &&

+	    { echo "$SYSTEM_NAME"; exit; }

+	echo mips-mips-riscos${UNAME_RELEASE}

+	exit ;;

+    Motorola:PowerMAX_OS:*:*)

+	echo powerpc-motorola-powermax

+	exit ;;

+    Motorola:*:4.3:PL8-*)

+	echo powerpc-harris-powermax

+	exit ;;

+    Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)

+	echo powerpc-harris-powermax

+	exit ;;

+    Night_Hawk:Power_UNIX:*:*)

+	echo powerpc-harris-powerunix

+	exit ;;

+    m88k:CX/UX:7*:*)

+	echo m88k-harris-cxux7

+	exit ;;

+    m88k:*:4*:R4*)

+	echo m88k-motorola-sysv4

+	exit ;;

+    m88k:*:3*:R3*)

+	echo m88k-motorola-sysv3

+	exit ;;

+    AViiON:dgux:*:*)

+        # DG/UX returns AViiON for all architectures

+        UNAME_PROCESSOR=`/usr/bin/uname -p`

+	if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]

+	then

+	    if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \

+	       [ ${TARGET_BINARY_INTERFACE}x = x ]

+	    then

+		echo m88k-dg-dgux${UNAME_RELEASE}

+	    else

+		echo m88k-dg-dguxbcs${UNAME_RELEASE}

+	    fi

+	else

+	    echo i586-dg-dgux${UNAME_RELEASE}

+	fi

+ 	exit ;;

+    M88*:DolphinOS:*:*)	# DolphinOS (SVR3)

+	echo m88k-dolphin-sysv3

+	exit ;;

+    M88*:*:R3*:*)

+	# Delta 88k system running SVR3

+	echo m88k-motorola-sysv3

+	exit ;;

+    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)

+	echo m88k-tektronix-sysv3

+	exit ;;

+    Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)

+	echo m68k-tektronix-bsd

+	exit ;;

+    *:IRIX*:*:*)

+	echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`

+	exit ;;

+    ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.

+	echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id

+	exit ;;               # Note that: echo "'`uname -s`'" gives 'AIX '

+    i*86:AIX:*:*)

+	echo i386-ibm-aix

+	exit ;;

+    ia64:AIX:*:*)

+	if [ -x /usr/bin/oslevel ] ; then

+		IBM_REV=`/usr/bin/oslevel`

+	else

+		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}

+	fi

+	echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}

+	exit ;;

+    *:AIX:2:3)

+	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then

+		eval $set_cc_for_build

+		sed 's/^		//' << EOF >$dummy.c

+		#include <sys/systemcfg.h>

+

+		main()

+			{

+			if (!__power_pc())

+				exit(1);

+			puts("powerpc-ibm-aix3.2.5");

+			exit(0);

+			}

+EOF

+		if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy`

+		then

+			echo "$SYSTEM_NAME"

+		else

+			echo rs6000-ibm-aix3.2.5

+		fi

+	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then

+		echo rs6000-ibm-aix3.2.4

+	else

+		echo rs6000-ibm-aix3.2

+	fi

+	exit ;;

+    *:AIX:*:[45])

+	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`

+	if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then

+		IBM_ARCH=rs6000

+	else

+		IBM_ARCH=powerpc

+	fi

+	if [ -x /usr/bin/oslevel ] ; then

+		IBM_REV=`/usr/bin/oslevel`

+	else

+		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}

+	fi

+	echo ${IBM_ARCH}-ibm-aix${IBM_REV}

+	exit ;;

+    *:AIX:*:*)

+	echo rs6000-ibm-aix

+	exit ;;

+    ibmrt:4.4BSD:*|romp-ibm:BSD:*)

+	echo romp-ibm-bsd4.4

+	exit ;;

+    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and

+	echo romp-ibm-bsd${UNAME_RELEASE}   # 4.3 with uname added to

+	exit ;;                             # report: romp-ibm BSD 4.3

+    *:BOSX:*:*)

+	echo rs6000-bull-bosx

+	exit ;;

+    DPX/2?00:B.O.S.:*:*)

+	echo m68k-bull-sysv3

+	exit ;;

+    9000/[34]??:4.3bsd:1.*:*)

+	echo m68k-hp-bsd

+	exit ;;

+    hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)

+	echo m68k-hp-bsd4.4

+	exit ;;

+    9000/[34678]??:HP-UX:*:*)

+	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`

+	case "${UNAME_MACHINE}" in

+	    9000/31? )            HP_ARCH=m68000 ;;

+	    9000/[34]?? )         HP_ARCH=m68k ;;

+	    9000/[678][0-9][0-9])

+		if [ -x /usr/bin/getconf ]; then

+		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`

+                    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`

+                    case "${sc_cpu_version}" in

+                      523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0

+                      528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1

+                      532)                      # CPU_PA_RISC2_0

+                        case "${sc_kernel_bits}" in

+                          32) HP_ARCH="hppa2.0n" ;;

+                          64) HP_ARCH="hppa2.0w" ;;

+			  '') HP_ARCH="hppa2.0" ;;   # HP-UX 10.20

+                        esac ;;

+                    esac

+		fi

+		if [ "${HP_ARCH}" = "" ]; then

+		    eval $set_cc_for_build

+		    sed 's/^              //' << EOF >$dummy.c

+

+              #define _HPUX_SOURCE

+              #include <stdlib.h>

+              #include <unistd.h>

+

+              int main ()

+              {

+              #if defined(_SC_KERNEL_BITS)

+                  long bits = sysconf(_SC_KERNEL_BITS);

+              #endif

+                  long cpu  = sysconf (_SC_CPU_VERSION);

+

+                  switch (cpu)

+              	{

+              	case CPU_PA_RISC1_0: puts ("hppa1.0"); break;

+              	case CPU_PA_RISC1_1: puts ("hppa1.1"); break;

+              	case CPU_PA_RISC2_0:

+              #if defined(_SC_KERNEL_BITS)

+              	    switch (bits)

+              		{

+              		case 64: puts ("hppa2.0w"); break;

+              		case 32: puts ("hppa2.0n"); break;

+              		default: puts ("hppa2.0"); break;

+              		} break;

+              #else  /* !defined(_SC_KERNEL_BITS) */

+              	    puts ("hppa2.0"); break;

+              #endif

+              	default: puts ("hppa1.0"); break;

+              	}

+                  exit (0);

+              }

+EOF

+		    (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`

+		    test -z "$HP_ARCH" && HP_ARCH=hppa

+		fi ;;

+	esac

+	if [ ${HP_ARCH} = "hppa2.0w" ]

+	then

+	    eval $set_cc_for_build

+

+	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating

+	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler

+	    # generating 64-bit code.  GNU and HP use different nomenclature:

+	    #

+	    # $ CC_FOR_BUILD=cc ./config.guess

+	    # => hppa2.0w-hp-hpux11.23

+	    # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess

+	    # => hppa64-hp-hpux11.23

+

+	    if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) |

+		grep __LP64__ >/dev/null

+	    then

+		HP_ARCH="hppa2.0w"

+	    else

+		HP_ARCH="hppa64"

+	    fi

+	fi

+	echo ${HP_ARCH}-hp-hpux${HPUX_REV}

+	exit ;;

+    ia64:HP-UX:*:*)

+	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`

+	echo ia64-hp-hpux${HPUX_REV}

+	exit ;;

+    3050*:HI-UX:*:*)

+	eval $set_cc_for_build

+	sed 's/^	//' << EOF >$dummy.c

+	#include <unistd.h>

+	int

+	main ()

+	{

+	  long cpu = sysconf (_SC_CPU_VERSION);

+	  /* The order matters, because CPU_IS_HP_MC68K erroneously returns

+	     true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct

+	     results, however.  */

+	  if (CPU_IS_PA_RISC (cpu))

+	    {

+	      switch (cpu)

+		{

+		  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;

+		  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;

+		  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;

+		  default: puts ("hppa-hitachi-hiuxwe2"); break;

+		}

+	    }

+	  else if (CPU_IS_HP_MC68K (cpu))

+	    puts ("m68k-hitachi-hiuxwe2");

+	  else puts ("unknown-hitachi-hiuxwe2");

+	  exit (0);

+	}

+EOF

+	$CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` &&

+		{ echo "$SYSTEM_NAME"; exit; }

+	echo unknown-hitachi-hiuxwe2

+	exit ;;

+    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )

+	echo hppa1.1-hp-bsd

+	exit ;;

+    9000/8??:4.3bsd:*:*)

+	echo hppa1.0-hp-bsd

+	exit ;;

+    *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)

+	echo hppa1.0-hp-mpeix

+	exit ;;

+    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )

+	echo hppa1.1-hp-osf

+	exit ;;

+    hp8??:OSF1:*:*)

+	echo hppa1.0-hp-osf

+	exit ;;

+    i*86:OSF1:*:*)

+	if [ -x /usr/sbin/sysversion ] ; then

+	    echo ${UNAME_MACHINE}-unknown-osf1mk

+	else

+	    echo ${UNAME_MACHINE}-unknown-osf1

+	fi

+	exit ;;

+    parisc*:Lites*:*:*)

+	echo hppa1.1-hp-lites

+	exit ;;

+    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)

+	echo c1-convex-bsd

+        exit ;;

+    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)

+	if getsysinfo -f scalar_acc

+	then echo c32-convex-bsd

+	else echo c2-convex-bsd

+	fi

+        exit ;;

+    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)

+	echo c34-convex-bsd

+        exit ;;

+    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)

+	echo c38-convex-bsd

+        exit ;;

+    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)

+	echo c4-convex-bsd

+        exit ;;

+    CRAY*Y-MP:*:*:*)

+	echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'

+	exit ;;

+    CRAY*[A-Z]90:*:*:*)

+	echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \

+	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \

+	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \

+	      -e 's/\.[^.]*$/.X/'

+	exit ;;

+    CRAY*TS:*:*:*)

+	echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'

+	exit ;;

+    CRAY*T3E:*:*:*)

+	echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'

+	exit ;;

+    CRAY*SV1:*:*:*)

+	echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'

+	exit ;;

+    *:UNICOS/mp:*:*)

+	echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'

+	exit ;;

+    F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)

+	FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`

+        FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`

+        FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`

+        echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"

+        exit ;;

+    5000:UNIX_System_V:4.*:*)

+        FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`

+        FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'`

+        echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"

+	exit ;;

+    i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)

+	echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}

+	exit ;;

+    sparc*:BSD/OS:*:*)

+	echo sparc-unknown-bsdi${UNAME_RELEASE}

+	exit ;;

+    *:BSD/OS:*:*)

+	echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}

+	exit ;;

+    *:FreeBSD:*:*)

+	echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`

+	exit ;;

+    i*:CYGWIN*:*)

+	echo ${UNAME_MACHINE}-pc-cygwin

+	exit ;;

+    i*:MINGW*:*)

+	echo ${UNAME_MACHINE}-pc-mingw32

+	exit ;;

+    i*:windows32*:*)

+    	# uname -m includes "-pc" on this system.

+    	echo ${UNAME_MACHINE}-mingw32

+	exit ;;

+    i*:PW*:*)

+	echo ${UNAME_MACHINE}-pc-pw32

+	exit ;;

+    x86:Interix*:[34]*)

+	echo i586-pc-interix${UNAME_RELEASE}|sed -e 's/\..*//'

+	exit ;;

+    [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)

+	echo i${UNAME_MACHINE}-pc-mks

+	exit ;;

+    i*:Windows_NT*:* | Pentium*:Windows_NT*:*)

+	# How do we know it's Interix rather than the generic POSIX subsystem?

+	# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we

+	# UNAME_MACHINE based on the output of uname instead of i386?

+	echo i586-pc-interix

+	exit ;;

+    i*:UWIN*:*)

+	echo ${UNAME_MACHINE}-pc-uwin

+	exit ;;

+    amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)

+	echo x86_64-unknown-cygwin

+	exit ;;

+    p*:CYGWIN*:*)

+	echo powerpcle-unknown-cygwin

+	exit ;;

+    prep*:SunOS:5.*:*)

+	echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`

+	exit ;;

+    *:GNU:*:*)

+	# the GNU system

+	echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`

+	exit ;;

+    *:GNU/*:*:*)

+	# other systems with GNU libc and userland

+	echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu

+	exit ;;

+    i*86:Minix:*:*)

+	echo ${UNAME_MACHINE}-pc-minix

+	exit ;;

+    arm*:Linux:*:*)

+	echo ${UNAME_MACHINE}-unknown-linux-gnu

+	exit ;;

+    cris:Linux:*:*)

+	echo cris-axis-linux-gnu

+	exit ;;

+    crisv32:Linux:*:*)

+	echo crisv32-axis-linux-gnu

+	exit ;;

+    frv:Linux:*:*)

+    	echo frv-unknown-linux-gnu

+	exit ;;

+    ia64:Linux:*:*)

+	echo ${UNAME_MACHINE}-unknown-linux-gnu

+	exit ;;

+    m32r*:Linux:*:*)

+	echo ${UNAME_MACHINE}-unknown-linux-gnu

+	exit ;;

+    m68*:Linux:*:*)

+	echo ${UNAME_MACHINE}-unknown-linux-gnu

+	exit ;;

+    mips:Linux:*:*)

+	eval $set_cc_for_build

+	sed 's/^	//' << EOF >$dummy.c

+	#undef CPU

+	#undef mips

+	#undef mipsel

+	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)

+	CPU=mipsel

+	#else

+	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)

+	CPU=mips

+	#else

+	CPU=

+	#endif

+	#endif

+EOF

+	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^CPU=`

+	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }

+	;;

+    mips64:Linux:*:*)

+	eval $set_cc_for_build

+	sed 's/^	//' << EOF >$dummy.c

+	#undef CPU

+	#undef mips64

+	#undef mips64el

+	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)

+	CPU=mips64el

+	#else

+	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)

+	CPU=mips64

+	#else

+	CPU=

+	#endif

+	#endif

+EOF

+	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^CPU=`

+	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }

+	;;

+    or32:Linux:*:*)

+	echo or32-unknown-linux-gnu

+	exit ;;

+    ppc:Linux:*:*)

+	echo powerpc-unknown-linux-gnu

+	exit ;;

+    ppc64:Linux:*:*)

+	echo powerpc64-unknown-linux-gnu

+	exit ;;

+    alpha:Linux:*:*)

+	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in

+	  EV5)   UNAME_MACHINE=alphaev5 ;;

+	  EV56)  UNAME_MACHINE=alphaev56 ;;

+	  PCA56) UNAME_MACHINE=alphapca56 ;;

+	  PCA57) UNAME_MACHINE=alphapca56 ;;

+	  EV6)   UNAME_MACHINE=alphaev6 ;;

+	  EV67)  UNAME_MACHINE=alphaev67 ;;

+	  EV68*) UNAME_MACHINE=alphaev68 ;;

+        esac

+	objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null

+	if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi

+	echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC}

+	exit ;;

+    parisc:Linux:*:* | hppa:Linux:*:*)

+	# Look for CPU level

+	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in

+	  PA7*) echo hppa1.1-unknown-linux-gnu ;;

+	  PA8*) echo hppa2.0-unknown-linux-gnu ;;

+	  *)    echo hppa-unknown-linux-gnu ;;

+	esac

+	exit ;;

+    parisc64:Linux:*:* | hppa64:Linux:*:*)

+	echo hppa64-unknown-linux-gnu

+	exit ;;

+    s390:Linux:*:* | s390x:Linux:*:*)

+	echo ${UNAME_MACHINE}-ibm-linux

+	exit ;;

+    sh64*:Linux:*:*)

+    	echo ${UNAME_MACHINE}-unknown-linux-gnu

+	exit ;;

+    sh*:Linux:*:*)

+	echo ${UNAME_MACHINE}-unknown-linux-gnu

+	exit ;;

+    sparc:Linux:*:* | sparc64:Linux:*:*)

+	echo ${UNAME_MACHINE}-unknown-linux-gnu

+	exit ;;

+    x86_64:Linux:*:*)

+	echo x86_64-unknown-linux-gnu

+	exit ;;

+    i*86:Linux:*:*)

+	# The BFD linker knows what the default object file format is, so

+	# first see if it will tell us. cd to the root directory to prevent

+	# problems with other programs or directories called `ld' in the path.

+	# Set LC_ALL=C to ensure ld outputs messages in English.

+	ld_supported_targets=`cd /; LC_ALL=C ld --help 2>&1 \

+			 | sed -ne '/supported targets:/!d

+				    s/[ 	][ 	]*/ /g

+				    s/.*supported targets: *//

+				    s/ .*//

+				    p'`

+        case "$ld_supported_targets" in

+	  elf32-i386)

+		TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu"

+		;;

+	  a.out-i386-linux)

+		echo "${UNAME_MACHINE}-pc-linux-gnuaout"

+		exit ;;

+	  coff-i386)

+		echo "${UNAME_MACHINE}-pc-linux-gnucoff"

+		exit ;;

+	  "")

+		# Either a pre-BFD a.out linker (linux-gnuoldld) or

+		# one that does not give us useful --help.

+		echo "${UNAME_MACHINE}-pc-linux-gnuoldld"

+		exit ;;

+	esac

+	# Determine whether the default compiler is a.out or elf

+	eval $set_cc_for_build

+	sed 's/^	//' << EOF >$dummy.c

+	#include <features.h>

+	#ifdef __ELF__

+	# ifdef __GLIBC__

+	#  if __GLIBC__ >= 2

+	LIBC=gnu

+	#  else

+	LIBC=gnulibc1

+	#  endif

+	# else

+	LIBC=gnulibc1

+	# endif

+	#else

+	#ifdef __INTEL_COMPILER

+	LIBC=gnu

+	#else

+	LIBC=gnuaout

+	#endif

+	#endif

+	#ifdef __dietlibc__

+	LIBC=dietlibc

+	#endif

+EOF

+	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^LIBC=`

+	test x"${LIBC}" != x && {

+		echo "${UNAME_MACHINE}-pc-linux-${LIBC}"

+		exit

+	}

+	test x"${TENTATIVE}" != x && { echo "${TENTATIVE}"; exit; }

+	;;

+    i*86:DYNIX/ptx:4*:*)

+	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.

+	# earlier versions are messed up and put the nodename in both

+	# sysname and nodename.

+	echo i386-sequent-sysv4

+	exit ;;

+    i*86:UNIX_SV:4.2MP:2.*)

+        # Unixware is an offshoot of SVR4, but it has its own version

+        # number series starting with 2...

+        # I am not positive that other SVR4 systems won't match this,

+	# I just have to hope.  -- rms.

+        # Use sysv4.2uw... so that sysv4* matches it.

+	echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}

+	exit ;;

+    i*86:OS/2:*:*)

+	# If we were able to find `uname', then EMX Unix compatibility

+	# is probably installed.

+	echo ${UNAME_MACHINE}-pc-os2-emx

+	exit ;;

+    i*86:XTS-300:*:STOP)

+	echo ${UNAME_MACHINE}-unknown-stop

+	exit ;;

+    i*86:atheos:*:*)

+	echo ${UNAME_MACHINE}-unknown-atheos

+	exit ;;

+    i*86:syllable:*:*)

+	echo ${UNAME_MACHINE}-pc-syllable

+	exit ;;

+    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*)

+	echo i386-unknown-lynxos${UNAME_RELEASE}

+	exit ;;

+    i*86:*DOS:*:*)

+	echo ${UNAME_MACHINE}-pc-msdosdjgpp

+	exit ;;

+    i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)

+	UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`

+	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then

+		echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}

+	else

+		echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}

+	fi

+	exit ;;

+    i*86:*:5:[678]*)

+    	# UnixWare 7.x, OpenUNIX and OpenServer 6.

+	case `/bin/uname -X | grep "^Machine"` in

+	    *486*)	     UNAME_MACHINE=i486 ;;

+	    *Pentium)	     UNAME_MACHINE=i586 ;;

+	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;

+	esac

+	echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}

+	exit ;;

+    i*86:*:3.2:*)

+	if test -f /usr/options/cb.name; then

+		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`

+		echo ${UNAME_MACHINE}-pc-isc$UNAME_REL

+	elif /bin/uname -X 2>/dev/null >/dev/null ; then

+		UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`

+		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486

+		(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \

+			&& UNAME_MACHINE=i586

+		(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \

+			&& UNAME_MACHINE=i686

+		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \

+			&& UNAME_MACHINE=i686

+		echo ${UNAME_MACHINE}-pc-sco$UNAME_REL

+	else

+		echo ${UNAME_MACHINE}-pc-sysv32

+	fi

+	exit ;;

+    pc:*:*:*)

+	# Left here for compatibility:

+        # uname -m prints for DJGPP always 'pc', but it prints nothing about

+        # the processor, so we play safe by assuming i386.

+	echo i386-pc-msdosdjgpp

+        exit ;;

+    Intel:Mach:3*:*)

+	echo i386-pc-mach3

+	exit ;;

+    paragon:*:*:*)

+	echo i860-intel-osf1

+	exit ;;

+    i860:*:4.*:*) # i860-SVR4

+	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then

+	  echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4

+	else # Add other i860-SVR4 vendors below as they are discovered.

+	  echo i860-unknown-sysv${UNAME_RELEASE}  # Unknown i860-SVR4

+	fi

+	exit ;;

+    mini*:CTIX:SYS*5:*)

+	# "miniframe"

+	echo m68010-convergent-sysv

+	exit ;;

+    mc68k:UNIX:SYSTEM5:3.51m)

+	echo m68k-convergent-sysv

+	exit ;;

+    M680?0:D-NIX:5.3:*)

+	echo m68k-diab-dnix

+	exit ;;

+    M68*:*:R3V[5678]*:*)

+	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;

+    3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)

+	OS_REL=''

+	test -r /etc/.relid \

+	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`

+	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \

+	  && { echo i486-ncr-sysv4.3${OS_REL}; exit; }

+	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \

+	  && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;

+    3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)

+        /bin/uname -p 2>/dev/null | grep 86 >/dev/null \

+          && { echo i486-ncr-sysv4; exit; } ;;

+    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)

+	echo m68k-unknown-lynxos${UNAME_RELEASE}

+	exit ;;

+    mc68030:UNIX_System_V:4.*:*)

+	echo m68k-atari-sysv4

+	exit ;;

+    TSUNAMI:LynxOS:2.*:*)

+	echo sparc-unknown-lynxos${UNAME_RELEASE}

+	exit ;;

+    rs6000:LynxOS:2.*:*)

+	echo rs6000-unknown-lynxos${UNAME_RELEASE}

+	exit ;;

+    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*)

+	echo powerpc-unknown-lynxos${UNAME_RELEASE}

+	exit ;;

+    SM[BE]S:UNIX_SV:*:*)

+	echo mips-dde-sysv${UNAME_RELEASE}

+	exit ;;

+    RM*:ReliantUNIX-*:*:*)

+	echo mips-sni-sysv4

+	exit ;;

+    RM*:SINIX-*:*:*)

+	echo mips-sni-sysv4

+	exit ;;

+    *:SINIX-*:*:*)

+	if uname -p 2>/dev/null >/dev/null ; then

+		UNAME_MACHINE=`(uname -p) 2>/dev/null`

+		echo ${UNAME_MACHINE}-sni-sysv4

+	else

+		echo ns32k-sni-sysv

+	fi

+	exit ;;

+    PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort

+                      # says <Richard.M.Bartel@ccMail.Census.GOV>

+        echo i586-unisys-sysv4

+        exit ;;

+    *:UNIX_System_V:4*:FTX*)

+	# From Gerald Hewes <hewes@openmarket.com>.

+	# How about differentiating between stratus architectures? -djm

+	echo hppa1.1-stratus-sysv4

+	exit ;;

+    *:*:*:FTX*)

+	# From seanf@swdc.stratus.com.

+	echo i860-stratus-sysv4

+	exit ;;

+    i*86:VOS:*:*)

+	# From Paul.Green@stratus.com.

+	echo ${UNAME_MACHINE}-stratus-vos

+	exit ;;

+    *:VOS:*:*)

+	# From Paul.Green@stratus.com.

+	echo hppa1.1-stratus-vos

+	exit ;;

+    mc68*:A/UX:*:*)

+	echo m68k-apple-aux${UNAME_RELEASE}

+	exit ;;

+    news*:NEWS-OS:6*:*)

+	echo mips-sony-newsos6

+	exit ;;

+    R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)

+	if [ -d /usr/nec ]; then

+	        echo mips-nec-sysv${UNAME_RELEASE}

+	else

+	        echo mips-unknown-sysv${UNAME_RELEASE}

+	fi

+        exit ;;

+    BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.

+	echo powerpc-be-beos

+	exit ;;

+    BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.

+	echo powerpc-apple-beos

+	exit ;;

+    BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.

+	echo i586-pc-beos

+	exit ;;

+    SX-4:SUPER-UX:*:*)

+	echo sx4-nec-superux${UNAME_RELEASE}

+	exit ;;

+    SX-5:SUPER-UX:*:*)

+	echo sx5-nec-superux${UNAME_RELEASE}

+	exit ;;

+    SX-6:SUPER-UX:*:*)

+	echo sx6-nec-superux${UNAME_RELEASE}

+	exit ;;

+    Power*:Rhapsody:*:*)

+	echo powerpc-apple-rhapsody${UNAME_RELEASE}

+	exit ;;

+    *:Rhapsody:*:*)

+	echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}

+	exit ;;

+    *:Darwin:*:*)

+	UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown

+	case $UNAME_PROCESSOR in

+	    *86) UNAME_PROCESSOR=i686 ;;

+	    unknown) UNAME_PROCESSOR=powerpc ;;

+	esac

+	echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}

+	exit ;;

+    *:procnto*:*:* | *:QNX:[0123456789]*:*)

+	UNAME_PROCESSOR=`uname -p`

+	if test "$UNAME_PROCESSOR" = "x86"; then

+		UNAME_PROCESSOR=i386

+		UNAME_MACHINE=pc

+	fi

+	echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}

+	exit ;;

+    *:QNX:*:4*)

+	echo i386-pc-qnx

+	exit ;;

+    NSE-?:NONSTOP_KERNEL:*:*)

+	echo nse-tandem-nsk${UNAME_RELEASE}

+	exit ;;

+    NSR-?:NONSTOP_KERNEL:*:*)

+	echo nsr-tandem-nsk${UNAME_RELEASE}

+	exit ;;

+    *:NonStop-UX:*:*)

+	echo mips-compaq-nonstopux

+	exit ;;

+    BS2000:POSIX*:*:*)

+	echo bs2000-siemens-sysv

+	exit ;;

+    DS/*:UNIX_System_V:*:*)

+	echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}

+	exit ;;

+    *:Plan9:*:*)

+	# "uname -m" is not consistent, so use $cputype instead. 386

+	# is converted to i386 for consistency with other x86

+	# operating systems.

+	if test "$cputype" = "386"; then

+	    UNAME_MACHINE=i386

+	else

+	    UNAME_MACHINE="$cputype"

+	fi

+	echo ${UNAME_MACHINE}-unknown-plan9

+	exit ;;

+    *:TOPS-10:*:*)

+	echo pdp10-unknown-tops10

+	exit ;;

+    *:TENEX:*:*)

+	echo pdp10-unknown-tenex

+	exit ;;

+    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)

+	echo pdp10-dec-tops20

+	exit ;;

+    XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)

+	echo pdp10-xkl-tops20

+	exit ;;

+    *:TOPS-20:*:*)

+	echo pdp10-unknown-tops20

+	exit ;;

+    *:ITS:*:*)

+	echo pdp10-unknown-its

+	exit ;;

+    SEI:*:*:SEIUX)

+        echo mips-sei-seiux${UNAME_RELEASE}

+	exit ;;

+    *:DragonFly:*:*)

+	echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`

+	exit ;;

+    *:*VMS:*:*)

+    	UNAME_MACHINE=`(uname -p) 2>/dev/null`

+	case "${UNAME_MACHINE}" in

+	    A*) echo alpha-dec-vms ; exit ;;

+	    I*) echo ia64-dec-vms ; exit ;;

+	    V*) echo vax-dec-vms ; exit ;;

+	esac ;;

+    *:XENIX:*:SysV)

+	echo i386-pc-xenix

+	exit ;;

+    i*86:skyos:*:*)

+	echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//'

+	exit ;;

+esac

+

+#echo '(No uname command or uname output not recognized.)' 1>&2

+#echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2

+

+eval $set_cc_for_build

+cat >$dummy.c <<EOF

+#ifdef _SEQUENT_

+# include <sys/types.h>

+# include <sys/utsname.h>

+#endif

+main ()

+{

+#if defined (sony)

+#if defined (MIPSEB)

+  /* BFD wants "bsd" instead of "newsos".  Perhaps BFD should be changed,

+     I don't know....  */

+  printf ("mips-sony-bsd\n"); exit (0);

+#else

+#include <sys/param.h>

+  printf ("m68k-sony-newsos%s\n",

+#ifdef NEWSOS4

+          "4"

+#else

+	  ""

+#endif

+         ); exit (0);

+#endif

+#endif

+

+#if defined (__arm) && defined (__acorn) && defined (__unix)

+  printf ("arm-acorn-riscix\n"); exit (0);

+#endif

+

+#if defined (hp300) && !defined (hpux)

+  printf ("m68k-hp-bsd\n"); exit (0);

+#endif

+

+#if defined (NeXT)

+#if !defined (__ARCHITECTURE__)

+#define __ARCHITECTURE__ "m68k"

+#endif

+  int version;

+  version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;

+  if (version < 4)

+    printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);

+  else

+    printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);

+  exit (0);

+#endif

+

+#if defined (MULTIMAX) || defined (n16)

+#if defined (UMAXV)

+  printf ("ns32k-encore-sysv\n"); exit (0);

+#else

+#if defined (CMU)

+  printf ("ns32k-encore-mach\n"); exit (0);

+#else

+  printf ("ns32k-encore-bsd\n"); exit (0);

+#endif

+#endif

+#endif

+

+#if defined (__386BSD__)

+  printf ("i386-pc-bsd\n"); exit (0);

+#endif

+

+#if defined (sequent)

+#if defined (i386)

+  printf ("i386-sequent-dynix\n"); exit (0);

+#endif

+#if defined (ns32000)

+  printf ("ns32k-sequent-dynix\n"); exit (0);

+#endif

+#endif

+

+#if defined (_SEQUENT_)

+    struct utsname un;

+

+    uname(&un);

+

+    if (strncmp(un.version, "V2", 2) == 0) {

+	printf ("i386-sequent-ptx2\n"); exit (0);

+    }

+    if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */

+	printf ("i386-sequent-ptx1\n"); exit (0);

+    }

+    printf ("i386-sequent-ptx\n"); exit (0);

+

+#endif

+

+#if defined (vax)

+# if !defined (ultrix)

+#  include <sys/param.h>

+#  if defined (BSD)

+#   if BSD == 43

+      printf ("vax-dec-bsd4.3\n"); exit (0);

+#   else

+#    if BSD == 199006

+      printf ("vax-dec-bsd4.3reno\n"); exit (0);

+#    else

+      printf ("vax-dec-bsd\n"); exit (0);

+#    endif

+#   endif

+#  else

+    printf ("vax-dec-bsd\n"); exit (0);

+#  endif

+# else

+    printf ("vax-dec-ultrix\n"); exit (0);

+# endif

+#endif

+

+#if defined (alliant) && defined (i860)

+  printf ("i860-alliant-bsd\n"); exit (0);

+#endif

+

+  exit (1);

+}

+EOF

+

+$CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` &&

+	{ echo "$SYSTEM_NAME"; exit; }

+

+# Apollos put the system type in the environment.

+

+test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; }

+

+# Convex versions that predate uname can use getsysinfo(1)

+

+if [ -x /usr/convex/getsysinfo ]

+then

+    case `getsysinfo -f cpu_type` in

+    c1*)

+	echo c1-convex-bsd

+	exit ;;

+    c2*)

+	if getsysinfo -f scalar_acc

+	then echo c32-convex-bsd

+	else echo c2-convex-bsd

+	fi

+	exit ;;

+    c34*)

+	echo c34-convex-bsd

+	exit ;;

+    c38*)

+	echo c38-convex-bsd

+	exit ;;

+    c4*)

+	echo c4-convex-bsd

+	exit ;;

+    esac

+fi

+

+cat >&2 <<EOF

+$0: unable to guess system type

+

+This script, last modified $timestamp, has failed to recognize

+the operating system you are using. It is advised that you

+download the most up to date version of the config scripts from

+

+  http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.guess

+and

+  http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.sub

+

+If the version you run ($0) is already up to date, please

+send the following data and any information you think might be

+pertinent to <config-patches@gnu.org> in order to provide the needed

+information to handle your system.

+

+config.guess timestamp = $timestamp

+

+uname -m = `(uname -m) 2>/dev/null || echo unknown`

+uname -r = `(uname -r) 2>/dev/null || echo unknown`

+uname -s = `(uname -s) 2>/dev/null || echo unknown`

+uname -v = `(uname -v) 2>/dev/null || echo unknown`

+

+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`

+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null`

+

+hostinfo               = `(hostinfo) 2>/dev/null`

+/bin/universe          = `(/bin/universe) 2>/dev/null`

+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`

+/bin/arch              = `(/bin/arch) 2>/dev/null`

+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`

+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`

+

+UNAME_MACHINE = ${UNAME_MACHINE}

+UNAME_RELEASE = ${UNAME_RELEASE}

+UNAME_SYSTEM  = ${UNAME_SYSTEM}

+UNAME_VERSION = ${UNAME_VERSION}

+EOF

+

+exit 1

+

+# Local variables:

+# eval: (add-hook 'write-file-hooks 'time-stamp)

+# time-stamp-start: "timestamp='"

+# time-stamp-format: "%:y-%02m-%02d"

+# time-stamp-end: "'"

+# End:

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/config.sub b/sdch/open_vcdiff/depot/opensource/open-vcdiff/config.sub
new file mode 100644
index 0000000..fb9af63
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/config.sub
@@ -0,0 +1,1579 @@
+#! /bin/sh

+# Configuration validation subroutine script.

+#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,

+#   2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.

+

+timestamp='2005-07-08'

+

+# This file is (in principle) common to ALL GNU software.

+# The presence of a machine in this file suggests that SOME GNU software

+# can handle that machine.  It does not imply ALL GNU software can.

+#

+# This file is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published by

+# the Free Software Foundation; either version 2 of the License, or

+# (at your option) any later version.

+#

+# This program is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with this program; if not, write to the Free Software

+# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA

+# 02110-1301, USA.

+#

+# As a special exception to the GNU General Public License, if you

+# distribute this file as part of a program that contains a

+# configuration script generated by Autoconf, you may include it under

+# the same distribution terms that you use for the rest of that program.

+

+

+# Please send patches to <config-patches@gnu.org>.  Submit a context

+# diff and a properly formatted ChangeLog entry.

+#

+# Configuration subroutine to validate and canonicalize a configuration type.

+# Supply the specified configuration type as an argument.

+# If it is invalid, we print an error message on stderr and exit with code 1.

+# Otherwise, we print the canonical config type on stdout and succeed.

+

+# This file is supposed to be the same for all GNU packages

+# and recognize all the CPU types, system types and aliases

+# that are meaningful with *any* GNU software.

+# Each package is responsible for reporting which valid configurations

+# it does not support.  The user should be able to distinguish

+# a failure to support a valid configuration from a meaningless

+# configuration.

+

+# The goal of this file is to map all the various variations of a given

+# machine specification into a single specification in the form:

+#	CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM

+# or in some cases, the newer four-part form:

+#	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM

+# It is wrong to echo any other type of specification.

+

+me=`echo "$0" | sed -e 's,.*/,,'`

+

+usage="\

+Usage: $0 [OPTION] CPU-MFR-OPSYS

+       $0 [OPTION] ALIAS

+

+Canonicalize a configuration name.

+

+Operation modes:

+  -h, --help         print this help, then exit

+  -t, --time-stamp   print date of last modification, then exit

+  -v, --version      print version number, then exit

+

+Report bugs and patches to <config-patches@gnu.org>."

+

+version="\

+GNU config.sub ($timestamp)

+

+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005

+Free Software Foundation, Inc.

+

+This is free software; see the source for copying conditions.  There is NO

+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."

+

+help="

+Try \`$me --help' for more information."

+

+# Parse command line

+while test $# -gt 0 ; do

+  case $1 in

+    --time-stamp | --time* | -t )

+       echo "$timestamp" ; exit ;;

+    --version | -v )

+       echo "$version" ; exit ;;

+    --help | --h* | -h )

+       echo "$usage"; exit ;;

+    -- )     # Stop option processing

+       shift; break ;;

+    - )	# Use stdin as input.

+       break ;;

+    -* )

+       echo "$me: invalid option $1$help"

+       exit 1 ;;

+

+    *local*)

+       # First pass through any local machine types.

+       echo $1

+       exit ;;

+

+    * )

+       break ;;

+  esac

+done

+

+case $# in

+ 0) echo "$me: missing argument$help" >&2

+    exit 1;;

+ 1) ;;

+ *) echo "$me: too many arguments$help" >&2

+    exit 1;;

+esac

+

+# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).

+# Here we must recognize all the valid KERNEL-OS combinations.

+maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`

+case $maybe_os in

+  nto-qnx* | linux-gnu* | linux-dietlibc | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | \

+  kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* | storm-chaos* | os2-emx* | rtmk-nova*)

+    os=-$maybe_os

+    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`

+    ;;

+  *)

+    basic_machine=`echo $1 | sed 's/-[^-]*$//'`

+    if [ $basic_machine != $1 ]

+    then os=`echo $1 | sed 's/.*-/-/'`

+    else os=; fi

+    ;;

+esac

+

+### Let's recognize common machines as not being operating systems so

+### that things like config.sub decstation-3100 work.  We also

+### recognize some manufacturers as not being operating systems, so we

+### can provide default operating systems below.

+case $os in

+	-sun*os*)

+		# Prevent following clause from handling this invalid input.

+		;;

+	-dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \

+	-att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \

+	-unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \

+	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\

+	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \

+	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \

+	-apple | -axis | -knuth | -cray)

+		os=

+		basic_machine=$1

+		;;

+	-sim | -cisco | -oki | -wec | -winbond)

+		os=

+		basic_machine=$1

+		;;

+	-scout)

+		;;

+	-wrs)

+		os=-vxworks

+		basic_machine=$1

+		;;

+	-chorusos*)

+		os=-chorusos

+		basic_machine=$1

+		;;

+ 	-chorusrdb)

+ 		os=-chorusrdb

+		basic_machine=$1

+ 		;;

+	-hiux*)

+		os=-hiuxwe2

+		;;

+	-sco5)

+		os=-sco3.2v5

+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`

+		;;

+	-sco4)

+		os=-sco3.2v4

+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`

+		;;

+	-sco3.2.[4-9]*)

+		os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`

+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`

+		;;

+	-sco3.2v[4-9]*)

+		# Don't forget version if it is 3.2v4 or newer.

+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`

+		;;

+	-sco*)

+		os=-sco3.2v2

+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`

+		;;

+	-udk*)

+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`

+		;;

+	-isc)

+		os=-isc2.2

+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`

+		;;

+	-clix*)

+		basic_machine=clipper-intergraph

+		;;

+	-isc*)

+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`

+		;;

+	-lynx*)

+		os=-lynxos

+		;;

+	-ptx*)

+		basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'`

+		;;

+	-windowsnt*)

+		os=`echo $os | sed -e 's/windowsnt/winnt/'`

+		;;

+	-psos*)

+		os=-psos

+		;;

+	-mint | -mint[0-9]*)

+		basic_machine=m68k-atari

+		os=-mint

+		;;

+esac

+

+# Decode aliases for certain CPU-COMPANY combinations.

+case $basic_machine in

+	# Recognize the basic CPU types without company name.

+	# Some are omitted here because they have special meanings below.

+	1750a | 580 \

+	| a29k \

+	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \

+	| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \

+	| am33_2.0 \

+	| arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr \

+	| bfin \

+	| c4x | clipper \

+	| d10v | d30v | dlx | dsp16xx \

+	| fr30 | frv \

+	| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \

+	| i370 | i860 | i960 | ia64 \

+	| ip2k | iq2000 \

+	| m32r | m32rle | m68000 | m68k | m88k | maxq | mcore \

+	| mips | mipsbe | mipseb | mipsel | mipsle \

+	| mips16 \

+	| mips64 | mips64el \

+	| mips64vr | mips64vrel \

+	| mips64orion | mips64orionel \

+	| mips64vr4100 | mips64vr4100el \

+	| mips64vr4300 | mips64vr4300el \

+	| mips64vr5000 | mips64vr5000el \

+	| mips64vr5900 | mips64vr5900el \

+	| mipsisa32 | mipsisa32el \

+	| mipsisa32r2 | mipsisa32r2el \

+	| mipsisa64 | mipsisa64el \

+	| mipsisa64r2 | mipsisa64r2el \

+	| mipsisa64sb1 | mipsisa64sb1el \

+	| mipsisa64sr71k | mipsisa64sr71kel \

+	| mipstx39 | mipstx39el \

+	| mn10200 | mn10300 \

+	| ms1 \

+	| msp430 \

+	| ns16k | ns32k \

+	| or32 \

+	| pdp10 | pdp11 | pj | pjl \

+	| powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \

+	| pyramid \

+	| sh | sh[1234] | sh[24]a | sh[23]e | sh[34]eb | shbe | shle | sh[1234]le | sh3ele \

+	| sh64 | sh64le \

+	| sparc | sparc64 | sparc64b | sparc86x | sparclet | sparclite \

+	| sparcv8 | sparcv9 | sparcv9b \

+	| strongarm \

+	| tahoe | thumb | tic4x | tic80 | tron \

+	| v850 | v850e \

+	| we32k \

+	| x86 | xscale | xscalee[bl] | xstormy16 | xtensa \

+	| z8k)

+		basic_machine=$basic_machine-unknown

+		;;

+	m32c)

+		basic_machine=$basic_machine-unknown

+		;;

+	m6811 | m68hc11 | m6812 | m68hc12)

+		# Motorola 68HC11/12.

+		basic_machine=$basic_machine-unknown

+		os=-none

+		;;

+	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)

+		;;

+

+	# We use `pc' rather than `unknown'

+	# because (1) that's what they normally are, and

+	# (2) the word "unknown" tends to confuse beginning users.

+	i*86 | x86_64)

+	  basic_machine=$basic_machine-pc

+	  ;;

+	# Object if more than one company name word.

+	*-*-*)

+		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2

+		exit 1

+		;;

+	# Recognize the basic CPU types with company name.

+	580-* \

+	| a29k-* \

+	| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \

+	| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \

+	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* \

+	| arm-*  | armbe-* | armle-* | armeb-* | armv*-* \

+	| avr-* \

+	| bfin-* | bs2000-* \

+	| c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \

+	| clipper-* | craynv-* | cydra-* \

+	| d10v-* | d30v-* | dlx-* \

+	| elxsi-* \

+	| f30[01]-* | f700-* | fr30-* | frv-* | fx80-* \

+	| h8300-* | h8500-* \

+	| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \

+	| i*86-* | i860-* | i960-* | ia64-* \

+	| ip2k-* | iq2000-* \

+	| m32r-* | m32rle-* \

+	| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \

+	| m88110-* | m88k-* | maxq-* | mcore-* \

+	| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \

+	| mips16-* \

+	| mips64-* | mips64el-* \

+	| mips64vr-* | mips64vrel-* \

+	| mips64orion-* | mips64orionel-* \

+	| mips64vr4100-* | mips64vr4100el-* \

+	| mips64vr4300-* | mips64vr4300el-* \

+	| mips64vr5000-* | mips64vr5000el-* \

+	| mips64vr5900-* | mips64vr5900el-* \

+	| mipsisa32-* | mipsisa32el-* \

+	| mipsisa32r2-* | mipsisa32r2el-* \

+	| mipsisa64-* | mipsisa64el-* \

+	| mipsisa64r2-* | mipsisa64r2el-* \

+	| mipsisa64sb1-* | mipsisa64sb1el-* \

+	| mipsisa64sr71k-* | mipsisa64sr71kel-* \

+	| mipstx39-* | mipstx39el-* \

+	| mmix-* \

+	| ms1-* \

+	| msp430-* \

+	| none-* | np1-* | ns16k-* | ns32k-* \

+	| orion-* \

+	| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \

+	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \

+	| pyramid-* \

+	| romp-* | rs6000-* \

+	| sh-* | sh[1234]-* | sh[24]a-* | sh[23]e-* | sh[34]eb-* | shbe-* \

+	| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \

+	| sparc-* | sparc64-* | sparc64b-* | sparc86x-* | sparclet-* \

+	| sparclite-* \

+	| sparcv8-* | sparcv9-* | sparcv9b-* | strongarm-* | sv1-* | sx?-* \

+	| tahoe-* | thumb-* \

+	| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \

+	| tron-* \

+	| v850-* | v850e-* | vax-* \

+	| we32k-* \

+	| x86-* | x86_64-* | xps100-* | xscale-* | xscalee[bl]-* \

+	| xstormy16-* | xtensa-* \

+	| ymp-* \

+	| z8k-*)

+		;;

+	m32c-*)

+		;;

+	# Recognize the various machine names and aliases which stand

+	# for a CPU type and a company and sometimes even an OS.

+	386bsd)

+		basic_machine=i386-unknown

+		os=-bsd

+		;;

+	3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)

+		basic_machine=m68000-att

+		;;

+	3b*)

+		basic_machine=we32k-att

+		;;

+	a29khif)

+		basic_machine=a29k-amd

+		os=-udi

+		;;

+    	abacus)

+		basic_machine=abacus-unknown

+		;;

+	adobe68k)

+		basic_machine=m68010-adobe

+		os=-scout

+		;;

+	alliant | fx80)

+		basic_machine=fx80-alliant

+		;;

+	altos | altos3068)

+		basic_machine=m68k-altos

+		;;

+	am29k)

+		basic_machine=a29k-none

+		os=-bsd

+		;;

+	amd64)

+		basic_machine=x86_64-pc

+		;;

+	amd64-*)

+		basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'`

+		;;

+	amdahl)

+		basic_machine=580-amdahl

+		os=-sysv

+		;;

+	amiga | amiga-*)

+		basic_machine=m68k-unknown

+		;;

+	amigaos | amigados)

+		basic_machine=m68k-unknown

+		os=-amigaos

+		;;

+	amigaunix | amix)

+		basic_machine=m68k-unknown

+		os=-sysv4

+		;;

+	apollo68)

+		basic_machine=m68k-apollo

+		os=-sysv

+		;;

+	apollo68bsd)

+		basic_machine=m68k-apollo

+		os=-bsd

+		;;

+	aux)

+		basic_machine=m68k-apple

+		os=-aux

+		;;

+	balance)

+		basic_machine=ns32k-sequent

+		os=-dynix

+		;;

+	c90)

+		basic_machine=c90-cray

+		os=-unicos

+		;;

+	convex-c1)

+		basic_machine=c1-convex

+		os=-bsd

+		;;

+	convex-c2)

+		basic_machine=c2-convex

+		os=-bsd

+		;;

+	convex-c32)

+		basic_machine=c32-convex

+		os=-bsd

+		;;

+	convex-c34)

+		basic_machine=c34-convex

+		os=-bsd

+		;;

+	convex-c38)

+		basic_machine=c38-convex

+		os=-bsd

+		;;

+	cray | j90)

+		basic_machine=j90-cray

+		os=-unicos

+		;;

+	craynv)

+		basic_machine=craynv-cray

+		os=-unicosmp

+		;;

+	cr16c)

+		basic_machine=cr16c-unknown

+		os=-elf

+		;;

+	crds | unos)

+		basic_machine=m68k-crds

+		;;

+	crisv32 | crisv32-* | etraxfs*)

+		basic_machine=crisv32-axis

+		;;

+	cris | cris-* | etrax*)

+		basic_machine=cris-axis

+		;;

+	crx)

+		basic_machine=crx-unknown

+		os=-elf

+		;;

+	da30 | da30-*)

+		basic_machine=m68k-da30

+		;;

+	decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)

+		basic_machine=mips-dec

+		;;

+	decsystem10* | dec10*)

+		basic_machine=pdp10-dec

+		os=-tops10

+		;;

+	decsystem20* | dec20*)

+		basic_machine=pdp10-dec

+		os=-tops20

+		;;

+	delta | 3300 | motorola-3300 | motorola-delta \

+	      | 3300-motorola | delta-motorola)

+		basic_machine=m68k-motorola

+		;;

+	delta88)

+		basic_machine=m88k-motorola

+		os=-sysv3

+		;;

+	djgpp)

+		basic_machine=i586-pc

+		os=-msdosdjgpp

+		;;

+	dpx20 | dpx20-*)

+		basic_machine=rs6000-bull

+		os=-bosx

+		;;

+	dpx2* | dpx2*-bull)

+		basic_machine=m68k-bull

+		os=-sysv3

+		;;

+	ebmon29k)

+		basic_machine=a29k-amd

+		os=-ebmon

+		;;

+	elxsi)

+		basic_machine=elxsi-elxsi

+		os=-bsd

+		;;

+	encore | umax | mmax)

+		basic_machine=ns32k-encore

+		;;

+	es1800 | OSE68k | ose68k | ose | OSE)

+		basic_machine=m68k-ericsson

+		os=-ose

+		;;

+	fx2800)

+		basic_machine=i860-alliant

+		;;

+	genix)

+		basic_machine=ns32k-ns

+		;;

+	gmicro)

+		basic_machine=tron-gmicro

+		os=-sysv

+		;;

+	go32)

+		basic_machine=i386-pc

+		os=-go32

+		;;

+	h3050r* | hiux*)

+		basic_machine=hppa1.1-hitachi

+		os=-hiuxwe2

+		;;

+	h8300hms)

+		basic_machine=h8300-hitachi

+		os=-hms

+		;;

+	h8300xray)

+		basic_machine=h8300-hitachi

+		os=-xray

+		;;

+	h8500hms)

+		basic_machine=h8500-hitachi

+		os=-hms

+		;;

+	harris)

+		basic_machine=m88k-harris

+		os=-sysv3

+		;;

+	hp300-*)

+		basic_machine=m68k-hp

+		;;

+	hp300bsd)

+		basic_machine=m68k-hp

+		os=-bsd

+		;;

+	hp300hpux)

+		basic_machine=m68k-hp

+		os=-hpux

+		;;

+	hp3k9[0-9][0-9] | hp9[0-9][0-9])

+		basic_machine=hppa1.0-hp

+		;;

+	hp9k2[0-9][0-9] | hp9k31[0-9])

+		basic_machine=m68000-hp

+		;;

+	hp9k3[2-9][0-9])

+		basic_machine=m68k-hp

+		;;

+	hp9k6[0-9][0-9] | hp6[0-9][0-9])

+		basic_machine=hppa1.0-hp

+		;;

+	hp9k7[0-79][0-9] | hp7[0-79][0-9])

+		basic_machine=hppa1.1-hp

+		;;

+	hp9k78[0-9] | hp78[0-9])

+		# FIXME: really hppa2.0-hp

+		basic_machine=hppa1.1-hp

+		;;

+	hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)

+		# FIXME: really hppa2.0-hp

+		basic_machine=hppa1.1-hp

+		;;

+	hp9k8[0-9][13679] | hp8[0-9][13679])

+		basic_machine=hppa1.1-hp

+		;;

+	hp9k8[0-9][0-9] | hp8[0-9][0-9])

+		basic_machine=hppa1.0-hp

+		;;

+	hppa-next)

+		os=-nextstep3

+		;;

+	hppaosf)

+		basic_machine=hppa1.1-hp

+		os=-osf

+		;;

+	hppro)

+		basic_machine=hppa1.1-hp

+		os=-proelf

+		;;

+	i370-ibm* | ibm*)

+		basic_machine=i370-ibm

+		;;

+# I'm not sure what "Sysv32" means.  Should this be sysv3.2?

+	i*86v32)

+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`

+		os=-sysv32

+		;;

+	i*86v4*)

+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`

+		os=-sysv4

+		;;

+	i*86v)

+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`

+		os=-sysv

+		;;

+	i*86sol2)

+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`

+		os=-solaris2

+		;;

+	i386mach)

+		basic_machine=i386-mach

+		os=-mach

+		;;

+	i386-vsta | vsta)

+		basic_machine=i386-unknown

+		os=-vsta

+		;;

+	iris | iris4d)

+		basic_machine=mips-sgi

+		case $os in

+		    -irix*)

+			;;

+		    *)

+			os=-irix4

+			;;

+		esac

+		;;

+	isi68 | isi)

+		basic_machine=m68k-isi

+		os=-sysv

+		;;

+	m88k-omron*)

+		basic_machine=m88k-omron

+		;;

+	magnum | m3230)

+		basic_machine=mips-mips

+		os=-sysv

+		;;

+	merlin)

+		basic_machine=ns32k-utek

+		os=-sysv

+		;;

+	mingw32)

+		basic_machine=i386-pc

+		os=-mingw32

+		;;

+	miniframe)

+		basic_machine=m68000-convergent

+		;;

+	*mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)

+		basic_machine=m68k-atari

+		os=-mint

+		;;

+	mips3*-*)

+		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`

+		;;

+	mips3*)

+		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown

+		;;

+	monitor)

+		basic_machine=m68k-rom68k

+		os=-coff

+		;;

+	morphos)

+		basic_machine=powerpc-unknown

+		os=-morphos

+		;;

+	msdos)

+		basic_machine=i386-pc

+		os=-msdos

+		;;

+	mvs)

+		basic_machine=i370-ibm

+		os=-mvs

+		;;

+	ncr3000)

+		basic_machine=i486-ncr

+		os=-sysv4

+		;;

+	netbsd386)

+		basic_machine=i386-unknown

+		os=-netbsd

+		;;

+	netwinder)

+		basic_machine=armv4l-rebel

+		os=-linux

+		;;

+	news | news700 | news800 | news900)

+		basic_machine=m68k-sony

+		os=-newsos

+		;;

+	news1000)

+		basic_machine=m68030-sony

+		os=-newsos

+		;;

+	news-3600 | risc-news)

+		basic_machine=mips-sony

+		os=-newsos

+		;;

+	necv70)

+		basic_machine=v70-nec

+		os=-sysv

+		;;

+	next | m*-next )

+		basic_machine=m68k-next

+		case $os in

+		    -nextstep* )

+			;;

+		    -ns2*)

+		      os=-nextstep2

+			;;

+		    *)

+		      os=-nextstep3

+			;;

+		esac

+		;;

+	nh3000)

+		basic_machine=m68k-harris

+		os=-cxux

+		;;

+	nh[45]000)

+		basic_machine=m88k-harris

+		os=-cxux

+		;;

+	nindy960)

+		basic_machine=i960-intel

+		os=-nindy

+		;;

+	mon960)

+		basic_machine=i960-intel

+		os=-mon960

+		;;

+	nonstopux)

+		basic_machine=mips-compaq

+		os=-nonstopux

+		;;

+	np1)

+		basic_machine=np1-gould

+		;;

+	nsr-tandem)

+		basic_machine=nsr-tandem

+		;;

+	op50n-* | op60c-*)

+		basic_machine=hppa1.1-oki

+		os=-proelf

+		;;

+	openrisc | openrisc-*)

+		basic_machine=or32-unknown

+		;;

+	os400)

+		basic_machine=powerpc-ibm

+		os=-os400

+		;;

+	OSE68000 | ose68000)

+		basic_machine=m68000-ericsson

+		os=-ose

+		;;

+	os68k)

+		basic_machine=m68k-none

+		os=-os68k

+		;;

+	pa-hitachi)

+		basic_machine=hppa1.1-hitachi

+		os=-hiuxwe2

+		;;

+	paragon)

+		basic_machine=i860-intel

+		os=-osf

+		;;

+	pbd)

+		basic_machine=sparc-tti

+		;;

+	pbb)

+		basic_machine=m68k-tti

+		;;

+	pc532 | pc532-*)

+		basic_machine=ns32k-pc532

+		;;

+	pentium | p5 | k5 | k6 | nexgen | viac3)

+		basic_machine=i586-pc

+		;;

+	pentiumpro | p6 | 6x86 | athlon | athlon_*)

+		basic_machine=i686-pc

+		;;

+	pentiumii | pentium2 | pentiumiii | pentium3)

+		basic_machine=i686-pc

+		;;

+	pentium4)

+		basic_machine=i786-pc

+		;;

+	pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)

+		basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`

+		;;

+	pentiumpro-* | p6-* | 6x86-* | athlon-*)

+		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`

+		;;

+	pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)

+		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`

+		;;

+	pentium4-*)

+		basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`

+		;;

+	pn)

+		basic_machine=pn-gould

+		;;

+	power)	basic_machine=power-ibm

+		;;

+	ppc)	basic_machine=powerpc-unknown

+		;;

+	ppc-*)	basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`

+		;;

+	ppcle | powerpclittle | ppc-le | powerpc-little)

+		basic_machine=powerpcle-unknown

+		;;

+	ppcle-* | powerpclittle-*)

+		basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`

+		;;

+	ppc64)	basic_machine=powerpc64-unknown

+		;;

+	ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`

+		;;

+	ppc64le | powerpc64little | ppc64-le | powerpc64-little)

+		basic_machine=powerpc64le-unknown

+		;;

+	ppc64le-* | powerpc64little-*)

+		basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`

+		;;

+	ps2)

+		basic_machine=i386-ibm

+		;;

+	pw32)

+		basic_machine=i586-unknown

+		os=-pw32

+		;;

+	rom68k)

+		basic_machine=m68k-rom68k

+		os=-coff

+		;;

+	rm[46]00)

+		basic_machine=mips-siemens

+		;;

+	rtpc | rtpc-*)

+		basic_machine=romp-ibm

+		;;

+	s390 | s390-*)

+		basic_machine=s390-ibm

+		;;

+	s390x | s390x-*)

+		basic_machine=s390x-ibm

+		;;

+	sa29200)

+		basic_machine=a29k-amd

+		os=-udi

+		;;

+	sb1)

+		basic_machine=mipsisa64sb1-unknown

+		;;

+	sb1el)

+		basic_machine=mipsisa64sb1el-unknown

+		;;

+	sei)

+		basic_machine=mips-sei

+		os=-seiux

+		;;

+	sequent)

+		basic_machine=i386-sequent

+		;;

+	sh)

+		basic_machine=sh-hitachi

+		os=-hms

+		;;

+	sh64)

+		basic_machine=sh64-unknown

+		;;

+	sparclite-wrs | simso-wrs)

+		basic_machine=sparclite-wrs

+		os=-vxworks

+		;;

+	sps7)

+		basic_machine=m68k-bull

+		os=-sysv2

+		;;

+	spur)

+		basic_machine=spur-unknown

+		;;

+	st2000)

+		basic_machine=m68k-tandem

+		;;

+	stratus)

+		basic_machine=i860-stratus

+		os=-sysv4

+		;;

+	sun2)

+		basic_machine=m68000-sun

+		;;

+	sun2os3)

+		basic_machine=m68000-sun

+		os=-sunos3

+		;;

+	sun2os4)

+		basic_machine=m68000-sun

+		os=-sunos4

+		;;

+	sun3os3)

+		basic_machine=m68k-sun

+		os=-sunos3

+		;;

+	sun3os4)

+		basic_machine=m68k-sun

+		os=-sunos4

+		;;

+	sun4os3)

+		basic_machine=sparc-sun

+		os=-sunos3

+		;;

+	sun4os4)

+		basic_machine=sparc-sun

+		os=-sunos4

+		;;

+	sun4sol2)

+		basic_machine=sparc-sun

+		os=-solaris2

+		;;

+	sun3 | sun3-*)

+		basic_machine=m68k-sun

+		;;

+	sun4)

+		basic_machine=sparc-sun

+		;;

+	sun386 | sun386i | roadrunner)

+		basic_machine=i386-sun

+		;;

+	sv1)

+		basic_machine=sv1-cray

+		os=-unicos

+		;;

+	symmetry)

+		basic_machine=i386-sequent

+		os=-dynix

+		;;

+	t3e)

+		basic_machine=alphaev5-cray

+		os=-unicos

+		;;

+	t90)

+		basic_machine=t90-cray

+		os=-unicos

+		;;

+	tic54x | c54x*)

+		basic_machine=tic54x-unknown

+		os=-coff

+		;;

+	tic55x | c55x*)

+		basic_machine=tic55x-unknown

+		os=-coff

+		;;

+	tic6x | c6x*)

+		basic_machine=tic6x-unknown

+		os=-coff

+		;;

+	tx39)

+		basic_machine=mipstx39-unknown

+		;;

+	tx39el)

+		basic_machine=mipstx39el-unknown

+		;;

+	toad1)

+		basic_machine=pdp10-xkl

+		os=-tops20

+		;;

+	tower | tower-32)

+		basic_machine=m68k-ncr

+		;;

+	tpf)

+		basic_machine=s390x-ibm

+		os=-tpf

+		;;

+	udi29k)

+		basic_machine=a29k-amd

+		os=-udi

+		;;

+	ultra3)

+		basic_machine=a29k-nyu

+		os=-sym1

+		;;

+	v810 | necv810)

+		basic_machine=v810-nec

+		os=-none

+		;;

+	vaxv)

+		basic_machine=vax-dec

+		os=-sysv

+		;;

+	vms)

+		basic_machine=vax-dec

+		os=-vms

+		;;

+	vpp*|vx|vx-*)

+		basic_machine=f301-fujitsu

+		;;

+	vxworks960)

+		basic_machine=i960-wrs

+		os=-vxworks

+		;;

+	vxworks68)

+		basic_machine=m68k-wrs

+		os=-vxworks

+		;;

+	vxworks29k)

+		basic_machine=a29k-wrs

+		os=-vxworks

+		;;

+	w65*)

+		basic_machine=w65-wdc

+		os=-none

+		;;

+	w89k-*)

+		basic_machine=hppa1.1-winbond

+		os=-proelf

+		;;

+	xbox)

+		basic_machine=i686-pc

+		os=-mingw32

+		;;

+	xps | xps100)

+		basic_machine=xps100-honeywell

+		;;

+	ymp)

+		basic_machine=ymp-cray

+		os=-unicos

+		;;

+	z8k-*-coff)

+		basic_machine=z8k-unknown

+		os=-sim

+		;;

+	none)

+		basic_machine=none-none

+		os=-none

+		;;

+

+# Here we handle the default manufacturer of certain CPU types.  It is in

+# some cases the only manufacturer, in others, it is the most popular.

+	w89k)

+		basic_machine=hppa1.1-winbond

+		;;

+	op50n)

+		basic_machine=hppa1.1-oki

+		;;

+	op60c)

+		basic_machine=hppa1.1-oki

+		;;

+	romp)

+		basic_machine=romp-ibm

+		;;

+	mmix)

+		basic_machine=mmix-knuth

+		;;

+	rs6000)

+		basic_machine=rs6000-ibm

+		;;

+	vax)

+		basic_machine=vax-dec

+		;;

+	pdp10)

+		# there are many clones, so DEC is not a safe bet

+		basic_machine=pdp10-unknown

+		;;

+	pdp11)

+		basic_machine=pdp11-dec

+		;;

+	we32k)

+		basic_machine=we32k-att

+		;;

+	sh[1234] | sh[24]a | sh[34]eb | sh[1234]le | sh[23]ele)

+		basic_machine=sh-unknown

+		;;

+	sparc | sparcv8 | sparcv9 | sparcv9b)

+		basic_machine=sparc-sun

+		;;

+	cydra)

+		basic_machine=cydra-cydrome

+		;;

+	orion)

+		basic_machine=orion-highlevel

+		;;

+	orion105)

+		basic_machine=clipper-highlevel

+		;;

+	mac | mpw | mac-mpw)

+		basic_machine=m68k-apple

+		;;

+	pmac | pmac-mpw)

+		basic_machine=powerpc-apple

+		;;

+	*-unknown)

+		# Make sure to match an already-canonicalized machine name.

+		;;

+	*)

+		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2

+		exit 1

+		;;

+esac

+

+# Here we canonicalize certain aliases for manufacturers.

+case $basic_machine in

+	*-digital*)

+		basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`

+		;;

+	*-commodore*)

+		basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`

+		;;

+	*)

+		;;

+esac

+

+# Decode manufacturer-specific aliases for certain operating systems.

+

+if [ x"$os" != x"" ]

+then

+case $os in

+        # First match some system type aliases

+        # that might get confused with valid system types.

+	# -solaris* is a basic system type, with this one exception.

+	-solaris1 | -solaris1.*)

+		os=`echo $os | sed -e 's|solaris1|sunos4|'`

+		;;

+	-solaris)

+		os=-solaris2

+		;;

+	-svr4*)

+		os=-sysv4

+		;;

+	-unixware*)

+		os=-sysv4.2uw

+		;;

+	-gnu/linux*)

+		os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`

+		;;

+	# First accept the basic system types.

+	# The portable systems comes first.

+	# Each alternative MUST END IN A *, to match a version number.

+	# -sysv* is not here because it comes later, after sysvr4.

+	-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \

+	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\

+	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \

+	      | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \

+	      | -aos* \

+	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \

+	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \

+	      | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* | -openbsd* \

+	      | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \

+	      | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \

+	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \

+	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \

+	      | -chorusos* | -chorusrdb* \

+	      | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \

+	      | -mingw32* | -linux-gnu* | -linux-uclibc* | -uxpv* | -beos* | -mpeix* | -udk* \

+	      | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \

+	      | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \

+	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \

+	      | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \

+	      | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \

+	      | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \

+	      | -skyos* | -haiku*)

+	# Remember, each alternative MUST END IN *, to match a version number.

+		;;

+	-qnx*)

+		case $basic_machine in

+		    x86-* | i*86-*)

+			;;

+		    *)

+			os=-nto$os

+			;;

+		esac

+		;;

+	-nto-qnx*)

+		;;

+	-nto*)

+		os=`echo $os | sed -e 's|nto|nto-qnx|'`

+		;;

+	-sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \

+	      | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \

+	      | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)

+		;;

+	-mac*)

+		os=`echo $os | sed -e 's|mac|macos|'`

+		;;

+	-linux-dietlibc)

+		os=-linux-dietlibc

+		;;

+	-linux*)

+		os=`echo $os | sed -e 's|linux|linux-gnu|'`

+		;;

+	-sunos5*)

+		os=`echo $os | sed -e 's|sunos5|solaris2|'`

+		;;

+	-sunos6*)

+		os=`echo $os | sed -e 's|sunos6|solaris3|'`

+		;;

+	-opened*)

+		os=-openedition

+		;;

+        -os400*)

+		os=-os400

+		;;

+	-wince*)

+		os=-wince

+		;;

+	-osfrose*)

+		os=-osfrose

+		;;

+	-osf*)

+		os=-osf

+		;;

+	-utek*)

+		os=-bsd

+		;;

+	-dynix*)

+		os=-bsd

+		;;

+	-acis*)

+		os=-aos

+		;;

+	-atheos*)

+		os=-atheos

+		;;

+	-syllable*)

+		os=-syllable

+		;;

+	-386bsd)

+		os=-bsd

+		;;

+	-ctix* | -uts*)

+		os=-sysv

+		;;

+	-nova*)

+		os=-rtmk-nova

+		;;

+	-ns2 )

+		os=-nextstep2

+		;;

+	-nsk*)

+		os=-nsk

+		;;

+	# Preserve the version number of sinix5.

+	-sinix5.*)

+		os=`echo $os | sed -e 's|sinix|sysv|'`

+		;;

+	-sinix*)

+		os=-sysv4

+		;;

+        -tpf*)

+		os=-tpf

+		;;

+	-triton*)

+		os=-sysv3

+		;;

+	-oss*)

+		os=-sysv3

+		;;

+	-svr4)

+		os=-sysv4

+		;;

+	-svr3)

+		os=-sysv3

+		;;

+	-sysvr4)

+		os=-sysv4

+		;;

+	# This must come after -sysvr4.

+	-sysv*)

+		;;

+	-ose*)

+		os=-ose

+		;;

+	-es1800*)

+		os=-ose

+		;;

+	-xenix)

+		os=-xenix

+		;;

+	-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)

+		os=-mint

+		;;

+	-aros*)

+		os=-aros

+		;;

+	-kaos*)

+		os=-kaos

+		;;

+	-zvmoe)

+		os=-zvmoe

+		;;

+	-none)

+		;;

+	*)

+		# Get rid of the `-' at the beginning of $os.

+		os=`echo $os | sed 's/[^-]*-//'`

+		echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2

+		exit 1

+		;;

+esac

+else

+

+# Here we handle the default operating systems that come with various machines.

+# The value should be what the vendor currently ships out the door with their

+# machine or put another way, the most popular os provided with the machine.

+

+# Note that if you're going to try to match "-MANUFACTURER" here (say,

+# "-sun"), then you have to tell the case statement up towards the top

+# that MANUFACTURER isn't an operating system.  Otherwise, code above

+# will signal an error saying that MANUFACTURER isn't an operating

+# system, and we'll never get to this point.

+

+case $basic_machine in

+	*-acorn)

+		os=-riscix1.2

+		;;

+	arm*-rebel)

+		os=-linux

+		;;

+	arm*-semi)

+		os=-aout

+		;;

+    c4x-* | tic4x-*)

+        os=-coff

+        ;;

+	# This must come before the *-dec entry.

+	pdp10-*)

+		os=-tops20

+		;;

+	pdp11-*)

+		os=-none

+		;;

+	*-dec | vax-*)

+		os=-ultrix4.2

+		;;

+	m68*-apollo)

+		os=-domain

+		;;

+	i386-sun)

+		os=-sunos4.0.2

+		;;

+	m68000-sun)

+		os=-sunos3

+		# This also exists in the configure program, but was not the

+		# default.

+		# os=-sunos4

+		;;

+	m68*-cisco)

+		os=-aout

+		;;

+	mips*-cisco)

+		os=-elf

+		;;

+	mips*-*)

+		os=-elf

+		;;

+	or32-*)

+		os=-coff

+		;;

+	*-tti)	# must be before sparc entry or we get the wrong os.

+		os=-sysv3

+		;;

+	sparc-* | *-sun)

+		os=-sunos4.1.1

+		;;

+	*-be)

+		os=-beos

+		;;

+	*-haiku)

+		os=-haiku

+		;;

+	*-ibm)

+		os=-aix

+		;;

+    	*-knuth)

+		os=-mmixware

+		;;

+	*-wec)

+		os=-proelf

+		;;

+	*-winbond)

+		os=-proelf

+		;;

+	*-oki)

+		os=-proelf

+		;;

+	*-hp)

+		os=-hpux

+		;;

+	*-hitachi)

+		os=-hiux

+		;;

+	i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)

+		os=-sysv

+		;;

+	*-cbm)

+		os=-amigaos

+		;;

+	*-dg)

+		os=-dgux

+		;;

+	*-dolphin)

+		os=-sysv3

+		;;

+	m68k-ccur)

+		os=-rtu

+		;;

+	m88k-omron*)

+		os=-luna

+		;;

+	*-next )

+		os=-nextstep

+		;;

+	*-sequent)

+		os=-ptx

+		;;

+	*-crds)

+		os=-unos

+		;;

+	*-ns)

+		os=-genix

+		;;

+	i370-*)

+		os=-mvs

+		;;

+	*-next)

+		os=-nextstep3

+		;;

+	*-gould)

+		os=-sysv

+		;;

+	*-highlevel)

+		os=-bsd

+		;;

+	*-encore)

+		os=-bsd

+		;;

+	*-sgi)

+		os=-irix

+		;;

+	*-siemens)

+		os=-sysv4

+		;;

+	*-masscomp)

+		os=-rtu

+		;;

+	f30[01]-fujitsu | f700-fujitsu)

+		os=-uxpv

+		;;

+	*-rom68k)

+		os=-coff

+		;;

+	*-*bug)

+		os=-coff

+		;;

+	*-apple)

+		os=-macos

+		;;

+	*-atari*)

+		os=-mint

+		;;

+	*)

+		os=-none

+		;;

+esac

+fi

+

+# Here we handle the case where we know the os, and the CPU type, but not the

+# manufacturer.  We pick the logical manufacturer.

+vendor=unknown

+case $basic_machine in

+	*-unknown)

+		case $os in

+			-riscix*)

+				vendor=acorn

+				;;

+			-sunos*)

+				vendor=sun

+				;;

+			-aix*)

+				vendor=ibm

+				;;

+			-beos*)

+				vendor=be

+				;;

+			-hpux*)

+				vendor=hp

+				;;

+			-mpeix*)

+				vendor=hp

+				;;

+			-hiux*)

+				vendor=hitachi

+				;;

+			-unos*)

+				vendor=crds

+				;;

+			-dgux*)

+				vendor=dg

+				;;

+			-luna*)

+				vendor=omron

+				;;

+			-genix*)

+				vendor=ns

+				;;

+			-mvs* | -opened*)

+				vendor=ibm

+				;;

+			-os400*)

+				vendor=ibm

+				;;

+			-ptx*)

+				vendor=sequent

+				;;

+			-tpf*)

+				vendor=ibm

+				;;

+			-vxsim* | -vxworks* | -windiss*)

+				vendor=wrs

+				;;

+			-aux*)

+				vendor=apple

+				;;

+			-hms*)

+				vendor=hitachi

+				;;

+			-mpw* | -macos*)

+				vendor=apple

+				;;

+			-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)

+				vendor=atari

+				;;

+			-vos*)

+				vendor=stratus

+				;;

+		esac

+		basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`

+		;;

+esac

+

+echo $basic_machine$os

+exit

+

+# Local variables:

+# eval: (add-hook 'write-file-hooks 'time-stamp)

+# time-stamp-start: "timestamp='"

+# time-stamp-format: "%:y-%02m-%02d"

+# time-stamp-end: "'"

+# End:

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/configure b/sdch/open_vcdiff/depot/opensource/open-vcdiff/configure
new file mode 100644
index 0000000..bba6e9e
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/configure
@@ -0,0 +1,23124 @@
+#! /bin/sh

+# Guess values for system-dependent variables and create Makefiles.

+# Generated by GNU Autoconf 2.59 for open-vcdiff 0.1.

+#

+# Report bugs to <opensource@google.com>.

+#

+# Copyright (C) 2003 Free Software Foundation, Inc.

+# This configure script is free software; the Free Software Foundation

+# gives unlimited permission to copy, distribute and modify it.

+## --------------------- ##

+## M4sh Initialization.  ##

+## --------------------- ##

+

+# Be Bourne compatible

+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then

+  emulate sh

+  NULLCMD=:

+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which

+  # is contrary to our usage.  Disable this feature.

+  alias -g '${1+"$@"}'='"$@"'

+elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then

+  set -o posix

+fi

+DUALCASE=1; export DUALCASE # for MKS sh

+

+# Support unset when possible.

+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then

+  as_unset=unset

+else

+  as_unset=false

+fi

+

+

+# Work around bugs in pre-3.0 UWIN ksh.

+$as_unset ENV MAIL MAILPATH

+PS1='$ '

+PS2='> '

+PS4='+ '

+

+# NLS nuisances.

+for as_var in \

+  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \

+  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \

+  LC_TELEPHONE LC_TIME

+do

+  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then

+    eval $as_var=C; export $as_var

+  else

+    $as_unset $as_var

+  fi

+done

+

+# Required to use basename.

+if expr a : '\(a\)' >/dev/null 2>&1; then

+  as_expr=expr

+else

+  as_expr=false

+fi

+

+if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then

+  as_basename=basename

+else

+  as_basename=false

+fi

+

+

+# Name of the executable.

+as_me=`$as_basename "$0" ||

+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \

+	 X"$0" : 'X\(//\)$' \| \

+	 X"$0" : 'X\(/\)$' \| \

+	 .     : '\(.\)' 2>/dev/null ||

+echo X/"$0" |

+    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }

+  	  /^X\/\(\/\/\)$/{ s//\1/; q; }

+  	  /^X\/\(\/\).*/{ s//\1/; q; }

+  	  s/.*/./; q'`

+

+

+# PATH needs CR, and LINENO needs CR and PATH.

+# Avoid depending upon Character Ranges.

+as_cr_letters='abcdefghijklmnopqrstuvwxyz'

+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'

+as_cr_Letters=$as_cr_letters$as_cr_LETTERS

+as_cr_digits='0123456789'

+as_cr_alnum=$as_cr_Letters$as_cr_digits

+

+# The user is always right.

+if test "${PATH_SEPARATOR+set}" != set; then

+  echo "#! /bin/sh" >conf$$.sh

+  echo  "exit 0"   >>conf$$.sh

+  chmod +x conf$$.sh

+  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then

+    PATH_SEPARATOR=';'

+  else

+    PATH_SEPARATOR=:

+  fi

+  rm -f conf$$.sh

+fi

+

+

+  as_lineno_1=$LINENO

+  as_lineno_2=$LINENO

+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`

+  test "x$as_lineno_1" != "x$as_lineno_2" &&

+  test "x$as_lineno_3"  = "x$as_lineno_2"  || {

+  # Find who we are.  Look in the path if we contain no path at all

+  # relative or not.

+  case $0 in

+    *[\\/]* ) as_myself=$0 ;;

+    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break

+done

+

+       ;;

+  esac

+  # We did not find ourselves, most probably we were run as `sh COMMAND'

+  # in which case we are not to be found in the path.

+  if test "x$as_myself" = x; then

+    as_myself=$0

+  fi

+  if test ! -f "$as_myself"; then

+    { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2

+   { (exit 1); exit 1; }; }

+  fi

+  case $CONFIG_SHELL in

+  '')

+    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for as_base in sh bash ksh sh5; do

+	 case $as_dir in

+	 /*)

+	   if ("$as_dir/$as_base" -c '

+  as_lineno_1=$LINENO

+  as_lineno_2=$LINENO

+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`

+  test "x$as_lineno_1" != "x$as_lineno_2" &&

+  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then

+	     $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }

+	     $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }

+	     CONFIG_SHELL=$as_dir/$as_base

+	     export CONFIG_SHELL

+	     exec "$CONFIG_SHELL" "$0" ${1+"$@"}

+	   fi;;

+	 esac

+       done

+done

+;;

+  esac

+

+  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO

+  # uniformly replaced by the line number.  The first 'sed' inserts a

+  # line-number line before each line; the second 'sed' does the real

+  # work.  The second script uses 'N' to pair each line-number line

+  # with the numbered line, and appends trailing '-' during

+  # substitution so that $LINENO is not a special case at line end.

+  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the

+  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)

+  sed '=' <$as_myself |

+    sed '

+      N

+      s,$,-,

+      : loop

+      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,

+      t loop

+      s,-$,,

+      s,^['$as_cr_digits']*\n,,

+    ' >$as_me.lineno &&

+  chmod +x $as_me.lineno ||

+    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2

+   { (exit 1); exit 1; }; }

+

+  # Don't try to exec as it changes $[0], causing all sort of problems

+  # (the dirname of $[0] is not the place where we might find the

+  # original and so on.  Autoconf is especially sensible to this).

+  . ./$as_me.lineno

+  # Exit status is that of the last command.

+  exit

+}

+

+

+case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in

+  *c*,-n*) ECHO_N= ECHO_C='

+' ECHO_T='	' ;;

+  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;

+  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;

+esac

+

+if expr a : '\(a\)' >/dev/null 2>&1; then

+  as_expr=expr

+else

+  as_expr=false

+fi

+

+rm -f conf$$ conf$$.exe conf$$.file

+echo >conf$$.file

+if ln -s conf$$.file conf$$ 2>/dev/null; then

+  # We could just check for DJGPP; but this test a) works b) is more generic

+  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).

+  if test -f conf$$.exe; then

+    # Don't use ln at all; we don't have any links

+    as_ln_s='cp -p'

+  else

+    as_ln_s='ln -s'

+  fi

+elif ln conf$$.file conf$$ 2>/dev/null; then

+  as_ln_s=ln

+else

+  as_ln_s='cp -p'

+fi

+rm -f conf$$ conf$$.exe conf$$.file

+

+if mkdir -p . 2>/dev/null; then

+  as_mkdir_p=:

+else

+  test -d ./-p && rmdir ./-p

+  as_mkdir_p=false

+fi

+

+as_executable_p="test -f"

+

+# Sed expression to map a string onto a valid CPP name.

+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"

+

+# Sed expression to map a string onto a valid variable name.

+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"

+

+

+# IFS

+# We need space, tab and new line, in precisely that order.

+as_nl='

+'

+IFS=" 	$as_nl"

+

+# CDPATH.

+$as_unset CDPATH

+

+

+

+# Check that we are running under the correct shell.

+SHELL=${CONFIG_SHELL-/bin/sh}

+

+case X$ECHO in

+X*--fallback-echo)

+  # Remove one level of quotation (which was required for Make).

+  ECHO=`echo "$ECHO" | sed 's,\\\\\$\\$0,'$0','`

+  ;;

+esac

+

+echo=${ECHO-echo}

+if test "X$1" = X--no-reexec; then

+  # Discard the --no-reexec flag, and continue.

+  shift

+elif test "X$1" = X--fallback-echo; then

+  # Avoid inline document here, it may be left over

+  :

+elif test "X`($echo '\t') 2>/dev/null`" = 'X\t' ; then

+  # Yippee, $echo works!

+  :

+else

+  # Restart under the correct shell.

+  exec $SHELL "$0" --no-reexec ${1+"$@"}

+fi

+

+if test "X$1" = X--fallback-echo; then

+  # used as fallback echo

+  shift

+  cat <<EOF

+$*

+EOF

+  exit 0

+fi

+

+# The HP-UX ksh and POSIX shell print the target directory to stdout

+# if CDPATH is set.

+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

+

+if test -z "$ECHO"; then

+if test "X${echo_test_string+set}" != Xset; then

+# find a string as large as possible, as long as the shell can cope with it

+  for cmd in 'sed 50q "$0"' 'sed 20q "$0"' 'sed 10q "$0"' 'sed 2q "$0"' 'echo test'; do

+    # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...

+    if (echo_test_string=`eval $cmd`) 2>/dev/null &&

+       echo_test_string=`eval $cmd` &&

+       (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null

+    then

+      break

+    fi

+  done

+fi

+

+if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&

+   echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&

+   test "X$echo_testing_string" = "X$echo_test_string"; then

+  :

+else

+  # The Solaris, AIX, and Digital Unix default echo programs unquote

+  # backslashes.  This makes it impossible to quote backslashes using

+  #   echo "$something" | sed 's/\\/\\\\/g'

+  #

+  # So, first we look for a working echo in the user's PATH.

+

+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

+  for dir in $PATH /usr/ucb; do

+    IFS="$lt_save_ifs"

+    if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&

+       test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&

+       echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&

+       test "X$echo_testing_string" = "X$echo_test_string"; then

+      echo="$dir/echo"

+      break

+    fi

+  done

+  IFS="$lt_save_ifs"

+

+  if test "X$echo" = Xecho; then

+    # We didn't find a better echo, so look for alternatives.

+    if test "X`(print -r '\t') 2>/dev/null`" = 'X\t' &&

+       echo_testing_string=`(print -r "$echo_test_string") 2>/dev/null` &&

+       test "X$echo_testing_string" = "X$echo_test_string"; then

+      # This shell has a builtin print -r that does the trick.

+      echo='print -r'

+    elif (test -f /bin/ksh || test -f /bin/ksh$ac_exeext) &&

+	 test "X$CONFIG_SHELL" != X/bin/ksh; then

+      # If we have ksh, try running configure again with it.

+      ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}

+      export ORIGINAL_CONFIG_SHELL

+      CONFIG_SHELL=/bin/ksh

+      export CONFIG_SHELL

+      exec $CONFIG_SHELL "$0" --no-reexec ${1+"$@"}

+    else

+      # Try using printf.

+      echo='printf %s\n'

+      if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&

+	 echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&

+	 test "X$echo_testing_string" = "X$echo_test_string"; then

+	# Cool, printf works

+	:

+      elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` &&

+	   test "X$echo_testing_string" = 'X\t' &&

+	   echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` &&

+	   test "X$echo_testing_string" = "X$echo_test_string"; then

+	CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL

+	export CONFIG_SHELL

+	SHELL="$CONFIG_SHELL"

+	export SHELL

+	echo="$CONFIG_SHELL $0 --fallback-echo"

+      elif echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` &&

+	   test "X$echo_testing_string" = 'X\t' &&

+	   echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` &&

+	   test "X$echo_testing_string" = "X$echo_test_string"; then

+	echo="$CONFIG_SHELL $0 --fallback-echo"

+      else

+	# maybe with a smaller string...

+	prev=:

+

+	for cmd in 'echo test' 'sed 2q "$0"' 'sed 10q "$0"' 'sed 20q "$0"' 'sed 50q "$0"'; do

+	  if (test "X$echo_test_string" = "X`eval $cmd`") 2>/dev/null

+	  then

+	    break

+	  fi

+	  prev="$cmd"

+	done

+

+	if test "$prev" != 'sed 50q "$0"'; then

+	  echo_test_string=`eval $prev`

+	  export echo_test_string

+	  exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "$0" ${1+"$@"}

+	else

+	  # Oops.  We lost completely, so just stick with echo.

+	  echo=echo

+	fi

+      fi

+    fi

+  fi

+fi

+fi

+

+# Copy echo and quote the copy suitably for passing to libtool from

+# the Makefile, instead of quoting the original, which is used later.

+ECHO=$echo

+if test "X$ECHO" = "X$CONFIG_SHELL $0 --fallback-echo"; then

+   ECHO="$CONFIG_SHELL \\\$\$0 --fallback-echo"

+fi

+

+

+

+

+tagnames=${tagnames+${tagnames},}CXX

+

+tagnames=${tagnames+${tagnames},}F77

+

+# Name of the host.

+# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,

+# so uname gets run too.

+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`

+

+exec 6>&1

+

+#

+# Initializations.

+#

+ac_default_prefix=/usr/local

+ac_config_libobj_dir=.

+cross_compiling=no

+subdirs=

+MFLAGS=

+MAKEFLAGS=

+SHELL=${CONFIG_SHELL-/bin/sh}

+

+# Maximum number of lines to put in a shell here document.

+# This variable seems obsolete.  It should probably be removed, and

+# only ac_max_sed_lines should be used.

+: ${ac_max_here_lines=38}

+

+# Identity of this package.

+PACKAGE_NAME='open-vcdiff'

+PACKAGE_TARNAME='open-vcdiff'

+PACKAGE_VERSION='0.1'

+PACKAGE_STRING='open-vcdiff 0.1'

+PACKAGE_BUGREPORT='opensource@google.com'

+

+ac_unique_file="README"

+# Factoring default headers for most tests.

+ac_includes_default="\

+#include <stdio.h>

+#if HAVE_SYS_TYPES_H

+# include <sys/types.h>

+#endif

+#if HAVE_SYS_STAT_H

+# include <sys/stat.h>

+#endif

+#if STDC_HEADERS

+# include <stdlib.h>

+# include <stddef.h>

+#else

+# if HAVE_STDLIB_H

+#  include <stdlib.h>

+# endif

+#endif

+#if HAVE_STRING_H

+# if !STDC_HEADERS && HAVE_MEMORY_H

+#  include <memory.h>

+# endif

+# include <string.h>

+#endif

+#if HAVE_STRINGS_H

+# include <strings.h>

+#endif

+#if HAVE_INTTYPES_H

+# include <inttypes.h>

+#else

+# if HAVE_STDINT_H

+#  include <stdint.h>

+# endif

+#endif

+#if HAVE_UNISTD_H

+# include <unistd.h>

+#endif"

+

+ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE am__leading_dot AMTAR am__tar am__untar CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE am__fastdepCC_TRUE am__fastdepCC_FALSE CPP CXX CXXFLAGS ac_ct_CXX CXXDEPMODE am__fastdepCXX_TRUE am__fastdepCXX_FALSE GCC_TRUE GCC_FALSE build build_cpu build_vendor build_os host host_cpu host_vendor host_os EGREP LN_S ECHO AR ac_ct_AR RANLIB ac_ct_RANLIB CXXCPP F77 FFLAGS ac_ct_F77 LIBTOOL LIBTOOL_DEPS acx_pthread_config PTHREAD_CC PTHREAD_LIBS PTHREAD_CFLAGS LIBOBJS LTLIBOBJS'

+ac_subst_files=''

+

+# Initialize some variables set by options.

+ac_init_help=

+ac_init_version=false

+# The variables have the same names as the options, with

+# dashes changed to underlines.

+cache_file=/dev/null

+exec_prefix=NONE

+no_create=

+no_recursion=

+prefix=NONE

+program_prefix=NONE

+program_suffix=NONE

+program_transform_name=s,x,x,

+silent=

+site=

+srcdir=

+verbose=

+x_includes=NONE

+x_libraries=NONE

+

+# Installation directory options.

+# These are left unexpanded so users can "make install exec_prefix=/foo"

+# and all the variables that are supposed to be based on exec_prefix

+# by default will actually change.

+# Use braces instead of parens because sh, perl, etc. also accept them.

+bindir='${exec_prefix}/bin'

+sbindir='${exec_prefix}/sbin'

+libexecdir='${exec_prefix}/libexec'

+datadir='${prefix}/share'

+sysconfdir='${prefix}/etc'

+sharedstatedir='${prefix}/com'

+localstatedir='${prefix}/var'

+libdir='${exec_prefix}/lib'

+includedir='${prefix}/include'

+oldincludedir='/usr/include'

+infodir='${prefix}/info'

+mandir='${prefix}/man'

+

+ac_prev=

+for ac_option

+do

+  # If the previous option needs an argument, assign it.

+  if test -n "$ac_prev"; then

+    eval "$ac_prev=\$ac_option"

+    ac_prev=

+    continue

+  fi

+

+  ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`

+

+  # Accept the important Cygnus configure options, so we can diagnose typos.

+

+  case $ac_option in

+

+  -bindir | --bindir | --bindi | --bind | --bin | --bi)

+    ac_prev=bindir ;;

+  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)

+    bindir=$ac_optarg ;;

+

+  -build | --build | --buil | --bui | --bu)

+    ac_prev=build_alias ;;

+  -build=* | --build=* | --buil=* | --bui=* | --bu=*)

+    build_alias=$ac_optarg ;;

+

+  -cache-file | --cache-file | --cache-fil | --cache-fi \

+  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)

+    ac_prev=cache_file ;;

+  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \

+  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)

+    cache_file=$ac_optarg ;;

+

+  --config-cache | -C)

+    cache_file=config.cache ;;

+

+  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)

+    ac_prev=datadir ;;

+  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \

+  | --da=*)

+    datadir=$ac_optarg ;;

+

+  -disable-* | --disable-*)

+    ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`

+    # Reject names that are not valid shell variable names.

+    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&

+      { echo "$as_me: error: invalid feature name: $ac_feature" >&2

+   { (exit 1); exit 1; }; }

+    ac_feature=`echo $ac_feature | sed 's/-/_/g'`

+    eval "enable_$ac_feature=no" ;;

+

+  -enable-* | --enable-*)

+    ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`

+    # Reject names that are not valid shell variable names.

+    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&

+      { echo "$as_me: error: invalid feature name: $ac_feature" >&2

+   { (exit 1); exit 1; }; }

+    ac_feature=`echo $ac_feature | sed 's/-/_/g'`

+    case $ac_option in

+      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;

+      *) ac_optarg=yes ;;

+    esac

+    eval "enable_$ac_feature='$ac_optarg'" ;;

+

+  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \

+  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \

+  | --exec | --exe | --ex)

+    ac_prev=exec_prefix ;;

+  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \

+  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \

+  | --exec=* | --exe=* | --ex=*)

+    exec_prefix=$ac_optarg ;;

+

+  -gas | --gas | --ga | --g)

+    # Obsolete; use --with-gas.

+    with_gas=yes ;;

+

+  -help | --help | --hel | --he | -h)

+    ac_init_help=long ;;

+  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)

+    ac_init_help=recursive ;;

+  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)

+    ac_init_help=short ;;

+

+  -host | --host | --hos | --ho)

+    ac_prev=host_alias ;;

+  -host=* | --host=* | --hos=* | --ho=*)

+    host_alias=$ac_optarg ;;

+

+  -includedir | --includedir | --includedi | --included | --include \

+  | --includ | --inclu | --incl | --inc)

+    ac_prev=includedir ;;

+  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \

+  | --includ=* | --inclu=* | --incl=* | --inc=*)

+    includedir=$ac_optarg ;;

+

+  -infodir | --infodir | --infodi | --infod | --info | --inf)

+    ac_prev=infodir ;;

+  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)

+    infodir=$ac_optarg ;;

+

+  -libdir | --libdir | --libdi | --libd)

+    ac_prev=libdir ;;

+  -libdir=* | --libdir=* | --libdi=* | --libd=*)

+    libdir=$ac_optarg ;;

+

+  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \

+  | --libexe | --libex | --libe)

+    ac_prev=libexecdir ;;

+  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \

+  | --libexe=* | --libex=* | --libe=*)

+    libexecdir=$ac_optarg ;;

+

+  -localstatedir | --localstatedir | --localstatedi | --localstated \

+  | --localstate | --localstat | --localsta | --localst \

+  | --locals | --local | --loca | --loc | --lo)

+    ac_prev=localstatedir ;;

+  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \

+  | --localstate=* | --localstat=* | --localsta=* | --localst=* \

+  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)

+    localstatedir=$ac_optarg ;;

+

+  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)

+    ac_prev=mandir ;;

+  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)

+    mandir=$ac_optarg ;;

+

+  -nfp | --nfp | --nf)

+    # Obsolete; use --without-fp.

+    with_fp=no ;;

+

+  -no-create | --no-create | --no-creat | --no-crea | --no-cre \

+  | --no-cr | --no-c | -n)

+    no_create=yes ;;

+

+  -no-recursion | --no-recursion | --no-recursio | --no-recursi \

+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)

+    no_recursion=yes ;;

+

+  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \

+  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \

+  | --oldin | --oldi | --old | --ol | --o)

+    ac_prev=oldincludedir ;;

+  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \

+  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \

+  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)

+    oldincludedir=$ac_optarg ;;

+

+  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)

+    ac_prev=prefix ;;

+  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)

+    prefix=$ac_optarg ;;

+

+  -program-prefix | --program-prefix | --program-prefi | --program-pref \

+  | --program-pre | --program-pr | --program-p)

+    ac_prev=program_prefix ;;

+  -program-prefix=* | --program-prefix=* | --program-prefi=* \

+  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)

+    program_prefix=$ac_optarg ;;

+

+  -program-suffix | --program-suffix | --program-suffi | --program-suff \

+  | --program-suf | --program-su | --program-s)

+    ac_prev=program_suffix ;;

+  -program-suffix=* | --program-suffix=* | --program-suffi=* \

+  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)

+    program_suffix=$ac_optarg ;;

+

+  -program-transform-name | --program-transform-name \

+  | --program-transform-nam | --program-transform-na \

+  | --program-transform-n | --program-transform- \

+  | --program-transform | --program-transfor \

+  | --program-transfo | --program-transf \

+  | --program-trans | --program-tran \

+  | --progr-tra | --program-tr | --program-t)

+    ac_prev=program_transform_name ;;

+  -program-transform-name=* | --program-transform-name=* \

+  | --program-transform-nam=* | --program-transform-na=* \

+  | --program-transform-n=* | --program-transform-=* \

+  | --program-transform=* | --program-transfor=* \

+  | --program-transfo=* | --program-transf=* \

+  | --program-trans=* | --program-tran=* \

+  | --progr-tra=* | --program-tr=* | --program-t=*)

+    program_transform_name=$ac_optarg ;;

+

+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \

+  | -silent | --silent | --silen | --sile | --sil)

+    silent=yes ;;

+

+  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)

+    ac_prev=sbindir ;;

+  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \

+  | --sbi=* | --sb=*)

+    sbindir=$ac_optarg ;;

+

+  -sharedstatedir | --sharedstatedir | --sharedstatedi \

+  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \

+  | --sharedst | --shareds | --shared | --share | --shar \

+  | --sha | --sh)

+    ac_prev=sharedstatedir ;;

+  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \

+  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \

+  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \

+  | --sha=* | --sh=*)

+    sharedstatedir=$ac_optarg ;;

+

+  -site | --site | --sit)

+    ac_prev=site ;;

+  -site=* | --site=* | --sit=*)

+    site=$ac_optarg ;;

+

+  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)

+    ac_prev=srcdir ;;

+  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)

+    srcdir=$ac_optarg ;;

+

+  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \

+  | --syscon | --sysco | --sysc | --sys | --sy)

+    ac_prev=sysconfdir ;;

+  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \

+  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)

+    sysconfdir=$ac_optarg ;;

+

+  -target | --target | --targe | --targ | --tar | --ta | --t)

+    ac_prev=target_alias ;;

+  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)

+    target_alias=$ac_optarg ;;

+

+  -v | -verbose | --verbose | --verbos | --verbo | --verb)

+    verbose=yes ;;

+

+  -version | --version | --versio | --versi | --vers | -V)

+    ac_init_version=: ;;

+

+  -with-* | --with-*)

+    ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`

+    # Reject names that are not valid shell variable names.

+    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&

+      { echo "$as_me: error: invalid package name: $ac_package" >&2

+   { (exit 1); exit 1; }; }

+    ac_package=`echo $ac_package| sed 's/-/_/g'`

+    case $ac_option in

+      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;

+      *) ac_optarg=yes ;;

+    esac

+    eval "with_$ac_package='$ac_optarg'" ;;

+

+  -without-* | --without-*)

+    ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`

+    # Reject names that are not valid shell variable names.

+    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&

+      { echo "$as_me: error: invalid package name: $ac_package" >&2

+   { (exit 1); exit 1; }; }

+    ac_package=`echo $ac_package | sed 's/-/_/g'`

+    eval "with_$ac_package=no" ;;

+

+  --x)

+    # Obsolete; use --with-x.

+    with_x=yes ;;

+

+  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \

+  | --x-incl | --x-inc | --x-in | --x-i)

+    ac_prev=x_includes ;;

+  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \

+  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)

+    x_includes=$ac_optarg ;;

+

+  -x-libraries | --x-libraries | --x-librarie | --x-librari \

+  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)

+    ac_prev=x_libraries ;;

+  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \

+  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)

+    x_libraries=$ac_optarg ;;

+

+  -*) { echo "$as_me: error: unrecognized option: $ac_option

+Try \`$0 --help' for more information." >&2

+   { (exit 1); exit 1; }; }

+    ;;

+

+  *=*)

+    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`

+    # Reject names that are not valid shell variable names.

+    expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&

+      { echo "$as_me: error: invalid variable name: $ac_envvar" >&2

+   { (exit 1); exit 1; }; }

+    ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`

+    eval "$ac_envvar='$ac_optarg'"

+    export $ac_envvar ;;

+

+  *)

+    # FIXME: should be removed in autoconf 3.0.

+    echo "$as_me: WARNING: you should use --build, --host, --target" >&2

+    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&

+      echo "$as_me: WARNING: invalid host type: $ac_option" >&2

+    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}

+    ;;

+

+  esac

+done

+

+if test -n "$ac_prev"; then

+  ac_option=--`echo $ac_prev | sed 's/_/-/g'`

+  { echo "$as_me: error: missing argument to $ac_option" >&2

+   { (exit 1); exit 1; }; }

+fi

+

+# Be sure to have absolute paths.

+for ac_var in exec_prefix prefix

+do

+  eval ac_val=$`echo $ac_var`

+  case $ac_val in

+    [\\/$]* | ?:[\\/]* | NONE | '' ) ;;

+    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2

+   { (exit 1); exit 1; }; };;

+  esac

+done

+

+# Be sure to have absolute paths.

+for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \

+	      localstatedir libdir includedir oldincludedir infodir mandir

+do

+  eval ac_val=$`echo $ac_var`

+  case $ac_val in

+    [\\/$]* | ?:[\\/]* ) ;;

+    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2

+   { (exit 1); exit 1; }; };;

+  esac

+done

+

+# There might be people who depend on the old broken behavior: `$host'

+# used to hold the argument of --host etc.

+# FIXME: To remove some day.

+build=$build_alias

+host=$host_alias

+target=$target_alias

+

+# FIXME: To remove some day.

+if test "x$host_alias" != x; then

+  if test "x$build_alias" = x; then

+    cross_compiling=maybe

+    echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.

+    If a cross compiler is detected then cross compile mode will be used." >&2

+  elif test "x$build_alias" != "x$host_alias"; then

+    cross_compiling=yes

+  fi

+fi

+

+ac_tool_prefix=

+test -n "$host_alias" && ac_tool_prefix=$host_alias-

+

+test "$silent" = yes && exec 6>/dev/null

+

+

+# Find the source files, if location was not specified.

+if test -z "$srcdir"; then

+  ac_srcdir_defaulted=yes

+  # Try the directory containing this script, then its parent.

+  ac_confdir=`(dirname "$0") 2>/dev/null ||

+$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \

+	 X"$0" : 'X\(//\)[^/]' \| \

+	 X"$0" : 'X\(//\)$' \| \

+	 X"$0" : 'X\(/\)' \| \

+	 .     : '\(.\)' 2>/dev/null ||

+echo X"$0" |

+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }

+  	  /^X\(\/\/\)$/{ s//\1/; q; }

+  	  /^X\(\/\).*/{ s//\1/; q; }

+  	  s/.*/./; q'`

+  srcdir=$ac_confdir

+  if test ! -r $srcdir/$ac_unique_file; then

+    srcdir=..

+  fi

+else

+  ac_srcdir_defaulted=no

+fi

+if test ! -r $srcdir/$ac_unique_file; then

+  if test "$ac_srcdir_defaulted" = yes; then

+    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2

+   { (exit 1); exit 1; }; }

+  else

+    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2

+   { (exit 1); exit 1; }; }

+  fi

+fi

+(cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||

+  { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2

+   { (exit 1); exit 1; }; }

+srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`

+ac_env_build_alias_set=${build_alias+set}

+ac_env_build_alias_value=$build_alias

+ac_cv_env_build_alias_set=${build_alias+set}

+ac_cv_env_build_alias_value=$build_alias

+ac_env_host_alias_set=${host_alias+set}

+ac_env_host_alias_value=$host_alias

+ac_cv_env_host_alias_set=${host_alias+set}

+ac_cv_env_host_alias_value=$host_alias

+ac_env_target_alias_set=${target_alias+set}

+ac_env_target_alias_value=$target_alias

+ac_cv_env_target_alias_set=${target_alias+set}

+ac_cv_env_target_alias_value=$target_alias

+ac_env_CC_set=${CC+set}

+ac_env_CC_value=$CC

+ac_cv_env_CC_set=${CC+set}

+ac_cv_env_CC_value=$CC

+ac_env_CFLAGS_set=${CFLAGS+set}

+ac_env_CFLAGS_value=$CFLAGS

+ac_cv_env_CFLAGS_set=${CFLAGS+set}

+ac_cv_env_CFLAGS_value=$CFLAGS

+ac_env_LDFLAGS_set=${LDFLAGS+set}

+ac_env_LDFLAGS_value=$LDFLAGS

+ac_cv_env_LDFLAGS_set=${LDFLAGS+set}

+ac_cv_env_LDFLAGS_value=$LDFLAGS

+ac_env_CPPFLAGS_set=${CPPFLAGS+set}

+ac_env_CPPFLAGS_value=$CPPFLAGS

+ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}

+ac_cv_env_CPPFLAGS_value=$CPPFLAGS

+ac_env_CPP_set=${CPP+set}

+ac_env_CPP_value=$CPP

+ac_cv_env_CPP_set=${CPP+set}

+ac_cv_env_CPP_value=$CPP

+ac_env_CXX_set=${CXX+set}

+ac_env_CXX_value=$CXX

+ac_cv_env_CXX_set=${CXX+set}

+ac_cv_env_CXX_value=$CXX

+ac_env_CXXFLAGS_set=${CXXFLAGS+set}

+ac_env_CXXFLAGS_value=$CXXFLAGS

+ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}

+ac_cv_env_CXXFLAGS_value=$CXXFLAGS

+ac_env_CXXCPP_set=${CXXCPP+set}

+ac_env_CXXCPP_value=$CXXCPP

+ac_cv_env_CXXCPP_set=${CXXCPP+set}

+ac_cv_env_CXXCPP_value=$CXXCPP

+ac_env_F77_set=${F77+set}

+ac_env_F77_value=$F77

+ac_cv_env_F77_set=${F77+set}

+ac_cv_env_F77_value=$F77

+ac_env_FFLAGS_set=${FFLAGS+set}

+ac_env_FFLAGS_value=$FFLAGS

+ac_cv_env_FFLAGS_set=${FFLAGS+set}

+ac_cv_env_FFLAGS_value=$FFLAGS

+

+#

+# Report the --help message.

+#

+if test "$ac_init_help" = "long"; then

+  # Omit some internal or obsolete options to make the list less imposing.

+  # This message is too long to be a string in the A/UX 3.1 sh.

+  cat <<_ACEOF

+\`configure' configures open-vcdiff 0.1 to adapt to many kinds of systems.

+

+Usage: $0 [OPTION]... [VAR=VALUE]...

+

+To assign environment variables (e.g., CC, CFLAGS...), specify them as

+VAR=VALUE.  See below for descriptions of some of the useful variables.

+

+Defaults for the options are specified in brackets.

+

+Configuration:

+  -h, --help              display this help and exit

+      --help=short        display options specific to this package

+      --help=recursive    display the short help of all the included packages

+  -V, --version           display version information and exit

+  -q, --quiet, --silent   do not print \`checking...' messages

+      --cache-file=FILE   cache test results in FILE [disabled]

+  -C, --config-cache      alias for \`--cache-file=config.cache'

+  -n, --no-create         do not create output files

+      --srcdir=DIR        find the sources in DIR [configure dir or \`..']

+

+_ACEOF

+

+  cat <<_ACEOF

+Installation directories:

+  --prefix=PREFIX         install architecture-independent files in PREFIX

+			  [$ac_default_prefix]

+  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX

+			  [PREFIX]

+

+By default, \`make install' will install all the files in

+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify

+an installation prefix other than \`$ac_default_prefix' using \`--prefix',

+for instance \`--prefix=\$HOME'.

+

+For better control, use the options below.

+

+Fine tuning of the installation directories:

+  --bindir=DIR           user executables [EPREFIX/bin]

+  --sbindir=DIR          system admin executables [EPREFIX/sbin]

+  --libexecdir=DIR       program executables [EPREFIX/libexec]

+  --datadir=DIR          read-only architecture-independent data [PREFIX/share]

+  --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]

+  --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]

+  --localstatedir=DIR    modifiable single-machine data [PREFIX/var]

+  --libdir=DIR           object code libraries [EPREFIX/lib]

+  --includedir=DIR       C header files [PREFIX/include]

+  --oldincludedir=DIR    C header files for non-gcc [/usr/include]

+  --infodir=DIR          info documentation [PREFIX/info]

+  --mandir=DIR           man documentation [PREFIX/man]

+_ACEOF

+

+  cat <<\_ACEOF

+

+Program names:

+  --program-prefix=PREFIX            prepend PREFIX to installed program names

+  --program-suffix=SUFFIX            append SUFFIX to installed program names

+  --program-transform-name=PROGRAM   run sed PROGRAM on installed program names

+

+System types:

+  --build=BUILD     configure for building on BUILD [guessed]

+  --host=HOST       cross-compile to build programs to run on HOST [BUILD]

+_ACEOF

+fi

+

+if test -n "$ac_init_help"; then

+  case $ac_init_help in

+     short | recursive ) echo "Configuration of open-vcdiff 0.1:";;

+   esac

+  cat <<\_ACEOF

+

+Optional Features:

+  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)

+  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]

+  --disable-dependency-tracking  speeds up one-time build

+  --enable-dependency-tracking   do not reject slow dependency extractors

+  --enable-shared[=PKGS]

+                          build shared libraries [default=yes]

+  --enable-static[=PKGS]

+                          build static libraries [default=yes]

+  --enable-fast-install[=PKGS]

+                          optimize for fast installation [default=yes]

+  --disable-libtool-lock  avoid locking (might break parallel builds)

+

+Optional Packages:

+  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]

+  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)

+  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]

+  --with-pic              try to use only PIC/non-PIC objects [default=use

+                          both]

+  --with-tags[=TAGS]

+                          include additional configurations [automatic]

+

+Some influential environment variables:

+  CC          C compiler command

+  CFLAGS      C compiler flags

+  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a

+              nonstandard directory <lib dir>

+  CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have

+              headers in a nonstandard directory <include dir>

+  CPP         C preprocessor

+  CXX         C++ compiler command

+  CXXFLAGS    C++ compiler flags

+  CXXCPP      C++ preprocessor

+  F77         Fortran 77 compiler command

+  FFLAGS      Fortran 77 compiler flags

+

+Use these variables to override the choices made by `configure' or to help

+it to find libraries and programs with nonstandard names/locations.

+

+Report bugs to <opensource@google.com>.

+_ACEOF

+fi

+

+if test "$ac_init_help" = "recursive"; then

+  # If there are subdirs, report their specific --help.

+  ac_popdir=`pwd`

+  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue

+    test -d $ac_dir || continue

+    ac_builddir=.

+

+if test "$ac_dir" != .; then

+  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`

+  # A "../" for each directory in $ac_dir_suffix.

+  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`

+else

+  ac_dir_suffix= ac_top_builddir=

+fi

+

+case $srcdir in

+  .)  # No --srcdir option.  We are building in place.

+    ac_srcdir=.

+    if test -z "$ac_top_builddir"; then

+       ac_top_srcdir=.

+    else

+       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`

+    fi ;;

+  [\\/]* | ?:[\\/]* )  # Absolute path.

+    ac_srcdir=$srcdir$ac_dir_suffix;

+    ac_top_srcdir=$srcdir ;;

+  *) # Relative path.

+    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix

+    ac_top_srcdir=$ac_top_builddir$srcdir ;;

+esac

+

+# Do not use `cd foo && pwd` to compute absolute paths, because

+# the directories may not exist.

+case `pwd` in

+.) ac_abs_builddir="$ac_dir";;

+*)

+  case "$ac_dir" in

+  .) ac_abs_builddir=`pwd`;;

+  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;

+  *) ac_abs_builddir=`pwd`/"$ac_dir";;

+  esac;;

+esac

+case $ac_abs_builddir in

+.) ac_abs_top_builddir=${ac_top_builddir}.;;

+*)

+  case ${ac_top_builddir}. in

+  .) ac_abs_top_builddir=$ac_abs_builddir;;

+  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;

+  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;

+  esac;;

+esac

+case $ac_abs_builddir in

+.) ac_abs_srcdir=$ac_srcdir;;

+*)

+  case $ac_srcdir in

+  .) ac_abs_srcdir=$ac_abs_builddir;;

+  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;

+  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;

+  esac;;

+esac

+case $ac_abs_builddir in

+.) ac_abs_top_srcdir=$ac_top_srcdir;;

+*)

+  case $ac_top_srcdir in

+  .) ac_abs_top_srcdir=$ac_abs_builddir;;

+  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;

+  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;

+  esac;;

+esac

+

+    cd $ac_dir

+    # Check for guested configure; otherwise get Cygnus style configure.

+    if test -f $ac_srcdir/configure.gnu; then

+      echo

+      $SHELL $ac_srcdir/configure.gnu  --help=recursive

+    elif test -f $ac_srcdir/configure; then

+      echo

+      $SHELL $ac_srcdir/configure  --help=recursive

+    elif test -f $ac_srcdir/configure.ac ||

+	   test -f $ac_srcdir/configure.in; then

+      echo

+      $ac_configure --help

+    else

+      echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2

+    fi

+    cd "$ac_popdir"

+  done

+fi

+

+test -n "$ac_init_help" && exit 0

+if $ac_init_version; then

+  cat <<\_ACEOF

+open-vcdiff configure 0.1

+generated by GNU Autoconf 2.59

+

+Copyright (C) 2003 Free Software Foundation, Inc.

+This configure script is free software; the Free Software Foundation

+gives unlimited permission to copy, distribute and modify it.

+_ACEOF

+  exit 0

+fi

+exec 5>config.log

+cat >&5 <<_ACEOF

+This file contains any messages produced by compilers while

+running configure, to aid debugging if configure makes a mistake.

+

+It was created by open-vcdiff $as_me 0.1, which was

+generated by GNU Autoconf 2.59.  Invocation command line was

+

+  $ $0 $@

+

+_ACEOF

+{

+cat <<_ASUNAME

+## --------- ##

+## Platform. ##

+## --------- ##

+

+hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`

+uname -m = `(uname -m) 2>/dev/null || echo unknown`

+uname -r = `(uname -r) 2>/dev/null || echo unknown`

+uname -s = `(uname -s) 2>/dev/null || echo unknown`

+uname -v = `(uname -v) 2>/dev/null || echo unknown`

+

+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`

+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`

+

+/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`

+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`

+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`

+hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`

+/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`

+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`

+/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`

+

+_ASUNAME

+

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  echo "PATH: $as_dir"

+done

+

+} >&5

+

+cat >&5 <<_ACEOF

+

+

+## ----------- ##

+## Core tests. ##

+## ----------- ##

+

+_ACEOF

+

+

+# Keep a trace of the command line.

+# Strip out --no-create and --no-recursion so they do not pile up.

+# Strip out --silent because we don't want to record it for future runs.

+# Also quote any args containing shell meta-characters.

+# Make two passes to allow for proper duplicate-argument suppression.

+ac_configure_args=

+ac_configure_args0=

+ac_configure_args1=

+ac_sep=

+ac_must_keep_next=false

+for ac_pass in 1 2

+do

+  for ac_arg

+  do

+    case $ac_arg in

+    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;

+    -q | -quiet | --quiet | --quie | --qui | --qu | --q \

+    | -silent | --silent | --silen | --sile | --sil)

+      continue ;;

+    *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)

+      ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;

+    esac

+    case $ac_pass in

+    1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;

+    2)

+      ac_configure_args1="$ac_configure_args1 '$ac_arg'"

+      if test $ac_must_keep_next = true; then

+	ac_must_keep_next=false # Got value, back to normal.

+      else

+	case $ac_arg in

+	  *=* | --config-cache | -C | -disable-* | --disable-* \

+	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \

+	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \

+	  | -with-* | --with-* | -without-* | --without-* | --x)

+	    case "$ac_configure_args0 " in

+	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;

+	    esac

+	    ;;

+	  -* ) ac_must_keep_next=true ;;

+	esac

+      fi

+      ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"

+      # Get rid of the leading space.

+      ac_sep=" "

+      ;;

+    esac

+  done

+done

+$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }

+$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }

+

+# When interrupted or exit'd, cleanup temporary files, and complete

+# config.log.  We remove comments because anyway the quotes in there

+# would cause problems or look ugly.

+# WARNING: Be sure not to use single quotes in there, as some shells,

+# such as our DU 5.0 friend, will then `close' the trap.

+trap 'exit_status=$?

+  # Save into config.log some information that might help in debugging.

+  {

+    echo

+

+    cat <<\_ASBOX

+## ---------------- ##

+## Cache variables. ##

+## ---------------- ##

+_ASBOX

+    echo

+    # The following way of writing the cache mishandles newlines in values,

+{

+  (set) 2>&1 |

+    case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in

+    *ac_space=\ *)

+      sed -n \

+	"s/'"'"'/'"'"'\\\\'"'"''"'"'/g;

+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"

+      ;;

+    *)

+      sed -n \

+	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"

+      ;;

+    esac;

+}

+    echo

+

+    cat <<\_ASBOX

+## ----------------- ##

+## Output variables. ##

+## ----------------- ##

+_ASBOX

+    echo

+    for ac_var in $ac_subst_vars

+    do

+      eval ac_val=$`echo $ac_var`

+      echo "$ac_var='"'"'$ac_val'"'"'"

+    done | sort

+    echo

+

+    if test -n "$ac_subst_files"; then

+      cat <<\_ASBOX

+## ------------- ##

+## Output files. ##

+## ------------- ##

+_ASBOX

+      echo

+      for ac_var in $ac_subst_files

+      do

+	eval ac_val=$`echo $ac_var`

+	echo "$ac_var='"'"'$ac_val'"'"'"

+      done | sort

+      echo

+    fi

+

+    if test -s confdefs.h; then

+      cat <<\_ASBOX

+## ----------- ##

+## confdefs.h. ##

+## ----------- ##

+_ASBOX

+      echo

+      sed "/^$/d" confdefs.h | sort

+      echo

+    fi

+    test "$ac_signal" != 0 &&

+      echo "$as_me: caught signal $ac_signal"

+    echo "$as_me: exit $exit_status"

+  } >&5

+  rm -f core *.core &&

+  rm -rf conftest* confdefs* conf$$* $ac_clean_files &&

+    exit $exit_status

+     ' 0

+for ac_signal in 1 2 13 15; do

+  trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal

+done

+ac_signal=0

+

+# confdefs.h avoids OS command line length limits that DEFS can exceed.

+rm -rf conftest* confdefs.h

+# AIX cpp loses on an empty file, so make sure it contains at least a newline.

+echo >confdefs.h

+

+# Predefined preprocessor variables.

+

+cat >>confdefs.h <<_ACEOF

+#define PACKAGE_NAME "$PACKAGE_NAME"

+_ACEOF

+

+

+cat >>confdefs.h <<_ACEOF

+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"

+_ACEOF

+

+

+cat >>confdefs.h <<_ACEOF

+#define PACKAGE_VERSION "$PACKAGE_VERSION"

+_ACEOF

+

+

+cat >>confdefs.h <<_ACEOF

+#define PACKAGE_STRING "$PACKAGE_STRING"

+_ACEOF

+

+

+cat >>confdefs.h <<_ACEOF

+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"

+_ACEOF

+

+

+# Let the site file select an alternate cache file if it wants to.

+# Prefer explicitly selected file to automatically selected ones.

+if test -z "$CONFIG_SITE"; then

+  if test "x$prefix" != xNONE; then

+    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"

+  else

+    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"

+  fi

+fi

+for ac_site_file in $CONFIG_SITE; do

+  if test -r "$ac_site_file"; then

+    { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5

+echo "$as_me: loading site script $ac_site_file" >&6;}

+    sed 's/^/| /' "$ac_site_file" >&5

+    . "$ac_site_file"

+  fi

+done

+

+if test -r "$cache_file"; then

+  # Some versions of bash will fail to source /dev/null (special

+  # files actually), so we avoid doing that.

+  if test -f "$cache_file"; then

+    { echo "$as_me:$LINENO: loading cache $cache_file" >&5

+echo "$as_me: loading cache $cache_file" >&6;}

+    case $cache_file in

+      [\\/]* | ?:[\\/]* ) . $cache_file;;

+      *)                      . ./$cache_file;;

+    esac

+  fi

+else

+  { echo "$as_me:$LINENO: creating cache $cache_file" >&5

+echo "$as_me: creating cache $cache_file" >&6;}

+  >$cache_file

+fi

+

+# Check that the precious variables saved in the cache have kept the same

+# value.

+ac_cache_corrupted=false

+for ac_var in `(set) 2>&1 |

+	       sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do

+  eval ac_old_set=\$ac_cv_env_${ac_var}_set

+  eval ac_new_set=\$ac_env_${ac_var}_set

+  eval ac_old_val="\$ac_cv_env_${ac_var}_value"

+  eval ac_new_val="\$ac_env_${ac_var}_value"

+  case $ac_old_set,$ac_new_set in

+    set,)

+      { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5

+echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}

+      ac_cache_corrupted=: ;;

+    ,set)

+      { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5

+echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}

+      ac_cache_corrupted=: ;;

+    ,);;

+    *)

+      if test "x$ac_old_val" != "x$ac_new_val"; then

+	{ echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5

+echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}

+	{ echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5

+echo "$as_me:   former value:  $ac_old_val" >&2;}

+	{ echo "$as_me:$LINENO:   current value: $ac_new_val" >&5

+echo "$as_me:   current value: $ac_new_val" >&2;}

+	ac_cache_corrupted=:

+      fi;;

+  esac

+  # Pass precious variables to config.status.

+  if test "$ac_new_set" = set; then

+    case $ac_new_val in

+    *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)

+      ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;

+    *) ac_arg=$ac_var=$ac_new_val ;;

+    esac

+    case " $ac_configure_args " in

+      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.

+      *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;

+    esac

+  fi

+done

+if $ac_cache_corrupted; then

+  { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5

+echo "$as_me: error: changes in the environment can compromise the build" >&2;}

+  { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5

+echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}

+   { (exit 1); exit 1; }; }

+fi

+

+ac_ext=c

+ac_cpp='$CPP $CPPFLAGS'

+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_c_compiler_gnu

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+am__api_version="1.9"

+ac_aux_dir=

+for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do

+  if test -f $ac_dir/install-sh; then

+    ac_aux_dir=$ac_dir

+    ac_install_sh="$ac_aux_dir/install-sh -c"

+    break

+  elif test -f $ac_dir/install.sh; then

+    ac_aux_dir=$ac_dir

+    ac_install_sh="$ac_aux_dir/install.sh -c"

+    break

+  elif test -f $ac_dir/shtool; then

+    ac_aux_dir=$ac_dir

+    ac_install_sh="$ac_aux_dir/shtool install -c"

+    break

+  fi

+done

+if test -z "$ac_aux_dir"; then

+  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5

+echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}

+   { (exit 1); exit 1; }; }

+fi

+ac_config_guess="$SHELL $ac_aux_dir/config.guess"

+ac_config_sub="$SHELL $ac_aux_dir/config.sub"

+ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.

+

+# Find a good install program.  We prefer a C program (faster),

+# so one script is as good as another.  But avoid the broken or

+# incompatible versions:

+# SysV /etc/install, /usr/sbin/install

+# SunOS /usr/etc/install

+# IRIX /sbin/install

+# AIX /bin/install

+# AmigaOS /C/install, which installs bootblocks on floppy discs

+# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag

+# AFS /usr/afsws/bin/install, which mishandles nonexistent args

+# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"

+# OS/2's system install, which has a completely different semantic

+# ./install, which can be erroneously created by make from ./install.sh.

+echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5

+echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6

+if test -z "$INSTALL"; then

+if test "${ac_cv_path_install+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  # Account for people who put trailing slashes in PATH elements.

+case $as_dir/ in

+  ./ | .// | /cC/* | \

+  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \

+  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \

+  /usr/ucb/* ) ;;

+  *)

+    # OSF1 and SCO ODT 3.0 have their own names for install.

+    # Don't use installbsd from OSF since it installs stuff as root

+    # by default.

+    for ac_prog in ginstall scoinst install; do

+      for ac_exec_ext in '' $ac_executable_extensions; do

+	if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then

+	  if test $ac_prog = install &&

+	    grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then

+	    # AIX install.  It has an incompatible calling convention.

+	    :

+	  elif test $ac_prog = install &&

+	    grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then

+	    # program-specific install script used by HP pwplus--don't use.

+	    :

+	  else

+	    ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"

+	    break 3

+	  fi

+	fi

+      done

+    done

+    ;;

+esac

+done

+

+

+fi

+  if test "${ac_cv_path_install+set}" = set; then

+    INSTALL=$ac_cv_path_install

+  else

+    # As a last resort, use the slow shell script.  We don't cache a

+    # path for INSTALL within a source directory, because that will

+    # break other packages using the cache if that directory is

+    # removed, or if the path is relative.

+    INSTALL=$ac_install_sh

+  fi

+fi

+echo "$as_me:$LINENO: result: $INSTALL" >&5

+echo "${ECHO_T}$INSTALL" >&6

+

+# Use test -z because SunOS4 sh mishandles braces in ${var-val}.

+# It thinks the first close brace ends the variable substitution.

+test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'

+

+test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'

+

+test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'

+

+echo "$as_me:$LINENO: checking whether build environment is sane" >&5

+echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6

+# Just in case

+sleep 1

+echo timestamp > conftest.file

+# Do `set' in a subshell so we don't clobber the current shell's

+# arguments.  Must try -L first in case configure is actually a

+# symlink; some systems play weird games with the mod time of symlinks

+# (eg FreeBSD returns the mod time of the symlink's containing

+# directory).

+if (

+   set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null`

+   if test "$*" = "X"; then

+      # -L didn't work.

+      set X `ls -t $srcdir/configure conftest.file`

+   fi

+   rm -f conftest.file

+   if test "$*" != "X $srcdir/configure conftest.file" \

+      && test "$*" != "X conftest.file $srcdir/configure"; then

+

+      # If neither matched, then we have a broken ls.  This can happen

+      # if, for instance, CONFIG_SHELL is bash and it inherits a

+      # broken ls alias from the environment.  This has actually

+      # happened.  Such a system could not be considered "sane".

+      { { echo "$as_me:$LINENO: error: ls -t appears to fail.  Make sure there is not a broken

+alias in your environment" >&5

+echo "$as_me: error: ls -t appears to fail.  Make sure there is not a broken

+alias in your environment" >&2;}

+   { (exit 1); exit 1; }; }

+   fi

+

+   test "$2" = conftest.file

+   )

+then

+   # Ok.

+   :

+else

+   { { echo "$as_me:$LINENO: error: newly created file is older than distributed files!

+Check your system clock" >&5

+echo "$as_me: error: newly created file is older than distributed files!

+Check your system clock" >&2;}

+   { (exit 1); exit 1; }; }

+fi

+echo "$as_me:$LINENO: result: yes" >&5

+echo "${ECHO_T}yes" >&6

+test "$program_prefix" != NONE &&

+  program_transform_name="s,^,$program_prefix,;$program_transform_name"

+# Use a double $ so make ignores it.

+test "$program_suffix" != NONE &&

+  program_transform_name="s,\$,$program_suffix,;$program_transform_name"

+# Double any \ or $.  echo might interpret backslashes.

+# By default was `s,x,x', remove it if useless.

+cat <<\_ACEOF >conftest.sed

+s/[\\$]/&&/g;s/;s,x,x,$//

+_ACEOF

+program_transform_name=`echo $program_transform_name | sed -f conftest.sed`

+rm conftest.sed

+

+# expand $ac_aux_dir to an absolute path

+am_aux_dir=`cd $ac_aux_dir && pwd`

+

+test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing"

+# Use eval to expand $SHELL

+if eval "$MISSING --run true"; then

+  am_missing_run="$MISSING --run "

+else

+  am_missing_run=

+  { echo "$as_me:$LINENO: WARNING: \`missing' script is too old or missing" >&5

+echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;}

+fi

+

+if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then

+  # We used to keeping the `.' as first argument, in order to

+  # allow $(mkdir_p) to be used without argument.  As in

+  #   $(mkdir_p) $(somedir)

+  # where $(somedir) is conditionally defined.  However this is wrong

+  # for two reasons:

+  #  1. if the package is installed by a user who cannot write `.'

+  #     make install will fail,

+  #  2. the above comment should most certainly read

+  #     $(mkdir_p) $(DESTDIR)$(somedir)

+  #     so it does not work when $(somedir) is undefined and

+  #     $(DESTDIR) is not.

+  #  To support the latter case, we have to write

+  #     test -z "$(somedir)" || $(mkdir_p) $(DESTDIR)$(somedir),

+  #  so the `.' trick is pointless.

+  mkdir_p='mkdir -p --'

+else

+  # On NextStep and OpenStep, the `mkdir' command does not

+  # recognize any option.  It will interpret all options as

+  # directories to create, and then abort because `.' already

+  # exists.

+  for d in ./-p ./--version;

+  do

+    test -d $d && rmdir $d

+  done

+  # $(mkinstalldirs) is defined by Automake if mkinstalldirs exists.

+  if test -f "$ac_aux_dir/mkinstalldirs"; then

+    mkdir_p='$(mkinstalldirs)'

+  else

+    mkdir_p='$(install_sh) -d'

+  fi

+fi

+

+for ac_prog in gawk mawk nawk awk

+do

+  # Extract the first word of "$ac_prog", so it can be a program name with args.

+set dummy $ac_prog; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_AWK+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$AWK"; then

+  ac_cv_prog_AWK="$AWK" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_AWK="$ac_prog"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+fi

+fi

+AWK=$ac_cv_prog_AWK

+if test -n "$AWK"; then

+  echo "$as_me:$LINENO: result: $AWK" >&5

+echo "${ECHO_T}$AWK" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+  test -n "$AWK" && break

+done

+

+echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5

+echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6

+set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`

+if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.make <<\_ACEOF

+all:

+	@echo 'ac_maketemp="$(MAKE)"'

+_ACEOF

+# GNU make sometimes prints "make[1]: Entering...", which would confuse us.

+eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`

+if test -n "$ac_maketemp"; then

+  eval ac_cv_prog_make_${ac_make}_set=yes

+else

+  eval ac_cv_prog_make_${ac_make}_set=no

+fi

+rm -f conftest.make

+fi

+if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then

+  echo "$as_me:$LINENO: result: yes" >&5

+echo "${ECHO_T}yes" >&6

+  SET_MAKE=

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+  SET_MAKE="MAKE=${MAKE-make}"

+fi

+

+rm -rf .tst 2>/dev/null

+mkdir .tst 2>/dev/null

+if test -d .tst; then

+  am__leading_dot=.

+else

+  am__leading_dot=_

+fi

+rmdir .tst 2>/dev/null

+

+# test to see if srcdir already configured

+if test "`cd $srcdir && pwd`" != "`pwd`" &&

+   test -f $srcdir/config.status; then

+  { { echo "$as_me:$LINENO: error: source directory already configured; run \"make distclean\" there first" >&5

+echo "$as_me: error: source directory already configured; run \"make distclean\" there first" >&2;}

+   { (exit 1); exit 1; }; }

+fi

+

+# test whether we have cygpath

+if test -z "$CYGPATH_W"; then

+  if (cygpath --version) >/dev/null 2>/dev/null; then

+    CYGPATH_W='cygpath -w'

+  else

+    CYGPATH_W=echo

+  fi

+fi

+

+

+# Define the identity of the package.

+ PACKAGE='open-vcdiff'

+ VERSION='0.1'

+

+

+cat >>confdefs.h <<_ACEOF

+#define PACKAGE "$PACKAGE"

+_ACEOF

+

+

+cat >>confdefs.h <<_ACEOF

+#define VERSION "$VERSION"

+_ACEOF

+

+# Some tools Automake needs.

+

+ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}

+

+

+AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}

+

+

+AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}

+

+

+AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}

+

+

+MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}

+

+install_sh=${install_sh-"$am_aux_dir/install-sh"}

+

+# Installed binaries are usually stripped using `strip' when the user

+# run `make install-strip'.  However `strip' might not be the right

+# tool to use in cross-compilation environments, therefore Automake

+# will honor the `STRIP' environment variable to overrule this program.

+if test "$cross_compiling" != no; then

+  if test -n "$ac_tool_prefix"; then

+  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.

+set dummy ${ac_tool_prefix}strip; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_STRIP+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$STRIP"; then

+  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_STRIP="${ac_tool_prefix}strip"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+fi

+fi

+STRIP=$ac_cv_prog_STRIP

+if test -n "$STRIP"; then

+  echo "$as_me:$LINENO: result: $STRIP" >&5

+echo "${ECHO_T}$STRIP" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+fi

+if test -z "$ac_cv_prog_STRIP"; then

+  ac_ct_STRIP=$STRIP

+  # Extract the first word of "strip", so it can be a program name with args.

+set dummy strip; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$ac_ct_STRIP"; then

+  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_ac_ct_STRIP="strip"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"

+fi

+fi

+ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP

+if test -n "$ac_ct_STRIP"; then

+  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5

+echo "${ECHO_T}$ac_ct_STRIP" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+  STRIP=$ac_ct_STRIP

+else

+  STRIP="$ac_cv_prog_STRIP"

+fi

+

+fi

+INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s"

+

+# We need awk for the "check" target.  The system "awk" is bad on

+# some platforms.

+# Always define AMTAR for backward compatibility.

+

+AMTAR=${AMTAR-"${am_missing_run}tar"}

+

+am__tar='${AMTAR} chof - "$$tardir"'; am__untar='${AMTAR} xf -'

+

+

+

+

+

+          ac_config_headers="$ac_config_headers src/config.h"

+

+

+# Checks for programs.

+ac_ext=c

+ac_cpp='$CPP $CPPFLAGS'

+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_c_compiler_gnu

+if test -n "$ac_tool_prefix"; then

+  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.

+set dummy ${ac_tool_prefix}gcc; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_CC+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$CC"; then

+  ac_cv_prog_CC="$CC" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_CC="${ac_tool_prefix}gcc"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+fi

+fi

+CC=$ac_cv_prog_CC

+if test -n "$CC"; then

+  echo "$as_me:$LINENO: result: $CC" >&5

+echo "${ECHO_T}$CC" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+fi

+if test -z "$ac_cv_prog_CC"; then

+  ac_ct_CC=$CC

+  # Extract the first word of "gcc", so it can be a program name with args.

+set dummy gcc; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$ac_ct_CC"; then

+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_ac_ct_CC="gcc"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+fi

+fi

+ac_ct_CC=$ac_cv_prog_ac_ct_CC

+if test -n "$ac_ct_CC"; then

+  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5

+echo "${ECHO_T}$ac_ct_CC" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+  CC=$ac_ct_CC

+else

+  CC="$ac_cv_prog_CC"

+fi

+

+if test -z "$CC"; then

+  if test -n "$ac_tool_prefix"; then

+  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.

+set dummy ${ac_tool_prefix}cc; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_CC+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$CC"; then

+  ac_cv_prog_CC="$CC" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_CC="${ac_tool_prefix}cc"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+fi

+fi

+CC=$ac_cv_prog_CC

+if test -n "$CC"; then

+  echo "$as_me:$LINENO: result: $CC" >&5

+echo "${ECHO_T}$CC" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+fi

+if test -z "$ac_cv_prog_CC"; then

+  ac_ct_CC=$CC

+  # Extract the first word of "cc", so it can be a program name with args.

+set dummy cc; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$ac_ct_CC"; then

+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_ac_ct_CC="cc"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+fi

+fi

+ac_ct_CC=$ac_cv_prog_ac_ct_CC

+if test -n "$ac_ct_CC"; then

+  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5

+echo "${ECHO_T}$ac_ct_CC" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+  CC=$ac_ct_CC

+else

+  CC="$ac_cv_prog_CC"

+fi

+

+fi

+if test -z "$CC"; then

+  # Extract the first word of "cc", so it can be a program name with args.

+set dummy cc; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_CC+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$CC"; then

+  ac_cv_prog_CC="$CC" # Let the user override the test.

+else

+  ac_prog_rejected=no

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then

+       ac_prog_rejected=yes

+       continue

+     fi

+    ac_cv_prog_CC="cc"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+if test $ac_prog_rejected = yes; then

+  # We found a bogon in the path, so make sure we never use it.

+  set dummy $ac_cv_prog_CC

+  shift

+  if test $# != 0; then

+    # We chose a different compiler from the bogus one.

+    # However, it has the same basename, so the bogon will be chosen

+    # first if we set CC to just the basename; use the full file name.

+    shift

+    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"

+  fi

+fi

+fi

+fi

+CC=$ac_cv_prog_CC

+if test -n "$CC"; then

+  echo "$as_me:$LINENO: result: $CC" >&5

+echo "${ECHO_T}$CC" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+fi

+if test -z "$CC"; then

+  if test -n "$ac_tool_prefix"; then

+  for ac_prog in cl

+  do

+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.

+set dummy $ac_tool_prefix$ac_prog; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_CC+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$CC"; then

+  ac_cv_prog_CC="$CC" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+fi

+fi

+CC=$ac_cv_prog_CC

+if test -n "$CC"; then

+  echo "$as_me:$LINENO: result: $CC" >&5

+echo "${ECHO_T}$CC" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+    test -n "$CC" && break

+  done

+fi

+if test -z "$CC"; then

+  ac_ct_CC=$CC

+  for ac_prog in cl

+do

+  # Extract the first word of "$ac_prog", so it can be a program name with args.

+set dummy $ac_prog; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$ac_ct_CC"; then

+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_ac_ct_CC="$ac_prog"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+fi

+fi

+ac_ct_CC=$ac_cv_prog_ac_ct_CC

+if test -n "$ac_ct_CC"; then

+  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5

+echo "${ECHO_T}$ac_ct_CC" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+  test -n "$ac_ct_CC" && break

+done

+

+  CC=$ac_ct_CC

+fi

+

+fi

+

+

+test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH

+See \`config.log' for more details." >&5

+echo "$as_me: error: no acceptable C compiler found in \$PATH

+See \`config.log' for more details." >&2;}

+   { (exit 1); exit 1; }; }

+

+# Provide some information about the compiler.

+echo "$as_me:$LINENO:" \

+     "checking for C compiler version" >&5

+ac_compiler=`set X $ac_compile; echo $2`

+{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5

+  (eval $ac_compiler --version </dev/null >&5) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }

+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5

+  (eval $ac_compiler -v </dev/null >&5) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }

+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5

+  (eval $ac_compiler -V </dev/null >&5) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }

+

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+int

+main ()

+{

+

+  ;

+  return 0;

+}

+_ACEOF

+ac_clean_files_save=$ac_clean_files

+ac_clean_files="$ac_clean_files a.out a.exe b.out"

+# Try to create an executable without -o first, disregard a.out.

+# It will help us diagnose broken compilers, and finding out an intuition

+# of exeext.

+echo "$as_me:$LINENO: checking for C compiler default output file name" >&5

+echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6

+ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`

+if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5

+  (eval $ac_link_default) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; then

+  # Find the output, starting from the most likely.  This scheme is

+# not robust to junk in `.', hence go to wildcards (a.*) only as a last

+# resort.

+

+# Be careful to initialize this variable, since it used to be cached.

+# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.

+ac_cv_exeext=

+# b.out is created by i960 compilers.

+for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out

+do

+  test -f "$ac_file" || continue

+  case $ac_file in

+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )

+	;;

+    conftest.$ac_ext )

+	# This is the source file.

+	;;

+    [ab].out )

+	# We found the default executable, but exeext='' is most

+	# certainly right.

+	break;;

+    *.* )

+	ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`

+	# FIXME: I believe we export ac_cv_exeext for Libtool,

+	# but it would be cool to find out if it's true.  Does anybody

+	# maintain Libtool? --akim.

+	export ac_cv_exeext

+	break;;

+    * )

+	break;;

+  esac

+done

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+{ { echo "$as_me:$LINENO: error: C compiler cannot create executables

+See \`config.log' for more details." >&5

+echo "$as_me: error: C compiler cannot create executables

+See \`config.log' for more details." >&2;}

+   { (exit 77); exit 77; }; }

+fi

+

+ac_exeext=$ac_cv_exeext

+echo "$as_me:$LINENO: result: $ac_file" >&5

+echo "${ECHO_T}$ac_file" >&6

+

+# Check the compiler produces executables we can run.  If not, either

+# the compiler is broken, or we cross compile.

+echo "$as_me:$LINENO: checking whether the C compiler works" >&5

+echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6

+# FIXME: These cross compiler hacks should be removed for Autoconf 3.0

+# If not cross compiling, check that we can run a simple program.

+if test "$cross_compiling" != yes; then

+  if { ac_try='./$ac_file'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+    cross_compiling=no

+  else

+    if test "$cross_compiling" = maybe; then

+	cross_compiling=yes

+    else

+	{ { echo "$as_me:$LINENO: error: cannot run C compiled programs.

+If you meant to cross compile, use \`--host'.

+See \`config.log' for more details." >&5

+echo "$as_me: error: cannot run C compiled programs.

+If you meant to cross compile, use \`--host'.

+See \`config.log' for more details." >&2;}

+   { (exit 1); exit 1; }; }

+    fi

+  fi

+fi

+echo "$as_me:$LINENO: result: yes" >&5

+echo "${ECHO_T}yes" >&6

+

+rm -f a.out a.exe conftest$ac_cv_exeext b.out

+ac_clean_files=$ac_clean_files_save

+# Check the compiler produces executables we can run.  If not, either

+# the compiler is broken, or we cross compile.

+echo "$as_me:$LINENO: checking whether we are cross compiling" >&5

+echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6

+echo "$as_me:$LINENO: result: $cross_compiling" >&5

+echo "${ECHO_T}$cross_compiling" >&6

+

+echo "$as_me:$LINENO: checking for suffix of executables" >&5

+echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; then

+  # If both `conftest.exe' and `conftest' are `present' (well, observable)

+# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will

+# work properly (i.e., refer to `conftest.exe'), while it won't with

+# `rm'.

+for ac_file in conftest.exe conftest conftest.*; do

+  test -f "$ac_file" || continue

+  case $ac_file in

+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;

+    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`

+	  export ac_cv_exeext

+	  break;;

+    * ) break;;

+  esac

+done

+else

+  { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link

+See \`config.log' for more details." >&5

+echo "$as_me: error: cannot compute suffix of executables: cannot compile and link

+See \`config.log' for more details." >&2;}

+   { (exit 1); exit 1; }; }

+fi

+

+rm -f conftest$ac_cv_exeext

+echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5

+echo "${ECHO_T}$ac_cv_exeext" >&6

+

+rm -f conftest.$ac_ext

+EXEEXT=$ac_cv_exeext

+ac_exeext=$EXEEXT

+echo "$as_me:$LINENO: checking for suffix of object files" >&5

+echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6

+if test "${ac_cv_objext+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+int

+main ()

+{

+

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.o conftest.obj

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; then

+  for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do

+  case $ac_file in

+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;

+    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`

+       break;;

+  esac

+done

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile

+See \`config.log' for more details." >&5

+echo "$as_me: error: cannot compute suffix of object files: cannot compile

+See \`config.log' for more details." >&2;}

+   { (exit 1); exit 1; }; }

+fi

+

+rm -f conftest.$ac_cv_objext conftest.$ac_ext

+fi

+echo "$as_me:$LINENO: result: $ac_cv_objext" >&5

+echo "${ECHO_T}$ac_cv_objext" >&6

+OBJEXT=$ac_cv_objext

+ac_objext=$OBJEXT

+echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5

+echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6

+if test "${ac_cv_c_compiler_gnu+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+int

+main ()

+{

+#ifndef __GNUC__

+       choke me

+#endif

+

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_compiler_gnu=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_compiler_gnu=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+ac_cv_c_compiler_gnu=$ac_compiler_gnu

+

+fi

+echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5

+echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6

+GCC=`test $ac_compiler_gnu = yes && echo yes`

+ac_test_CFLAGS=${CFLAGS+set}

+ac_save_CFLAGS=$CFLAGS

+CFLAGS="-g"

+echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5

+echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6

+if test "${ac_cv_prog_cc_g+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+int

+main ()

+{

+

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_cv_prog_cc_g=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_cv_prog_cc_g=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+fi

+echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5

+echo "${ECHO_T}$ac_cv_prog_cc_g" >&6

+if test "$ac_test_CFLAGS" = set; then

+  CFLAGS=$ac_save_CFLAGS

+elif test $ac_cv_prog_cc_g = yes; then

+  if test "$GCC" = yes; then

+    CFLAGS="-g -O2"

+  else

+    CFLAGS="-g"

+  fi

+else

+  if test "$GCC" = yes; then

+    CFLAGS="-O2"

+  else

+    CFLAGS=

+  fi

+fi

+echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5

+echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6

+if test "${ac_cv_prog_cc_stdc+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  ac_cv_prog_cc_stdc=no

+ac_save_CC=$CC

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <stdarg.h>

+#include <stdio.h>

+#include <sys/types.h>

+#include <sys/stat.h>

+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */

+struct buf { int x; };

+FILE * (*rcsopen) (struct buf *, struct stat *, int);

+static char *e (p, i)

+     char **p;

+     int i;

+{

+  return p[i];

+}

+static char *f (char * (*g) (char **, int), char **p, ...)

+{

+  char *s;

+  va_list v;

+  va_start (v,p);

+  s = g (p, va_arg (v,int));

+  va_end (v);

+  return s;

+}

+

+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has

+   function prototypes and stuff, but not '\xHH' hex character constants.

+   These don't provoke an error unfortunately, instead are silently treated

+   as 'x'.  The following induces an error, until -std1 is added to get

+   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an

+   array size at least.  It's necessary to write '\x00'==0 to get something

+   that's true only with -std1.  */

+int osf4_cc_array ['\x00' == 0 ? 1 : -1];

+

+int test (int i, double x);

+struct s1 {int (*f) (int a);};

+struct s2 {int (*f) (double a);};

+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);

+int argc;

+char **argv;

+int

+main ()

+{

+return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];

+  ;

+  return 0;

+}

+_ACEOF

+# Don't try gcc -ansi; that turns off useful extensions and

+# breaks some systems' header files.

+# AIX			-qlanglvl=ansi

+# Ultrix and OSF/1	-std1

+# HP-UX 10.20 and later	-Ae

+# HP-UX older versions	-Aa -D_HPUX_SOURCE

+# SVR4			-Xc -D__EXTENSIONS__

+for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"

+do

+  CC="$ac_save_CC $ac_arg"

+  rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_cv_prog_cc_stdc=$ac_arg

+break

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext

+done

+rm -f conftest.$ac_ext conftest.$ac_objext

+CC=$ac_save_CC

+

+fi

+

+case "x$ac_cv_prog_cc_stdc" in

+  x|xno)

+    echo "$as_me:$LINENO: result: none needed" >&5

+echo "${ECHO_T}none needed" >&6 ;;

+  *)

+    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5

+echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6

+    CC="$CC $ac_cv_prog_cc_stdc" ;;

+esac

+

+# Some people use a C++ compiler to compile C.  Since we use `exit',

+# in C++ we need to declare it.  In case someone uses the same compiler

+# for both compiling C and C++ we need to have the C++ compiler decide

+# the declaration of exit, since it's the most demanding environment.

+cat >conftest.$ac_ext <<_ACEOF

+#ifndef __cplusplus

+  choke me

+#endif

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  for ac_declaration in \

+   '' \

+   'extern "C" void std::exit (int) throw (); using std::exit;' \

+   'extern "C" void std::exit (int); using std::exit;' \

+   'extern "C" void exit (int) throw ();' \

+   'extern "C" void exit (int);' \

+   'void exit (int);'

+do

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_declaration

+#include <stdlib.h>

+int

+main ()

+{

+exit (42);

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  :

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+continue

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_declaration

+int

+main ()

+{

+exit (42);

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  break

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+done

+rm -f conftest*

+if test -n "$ac_declaration"; then

+  echo '#ifdef __cplusplus' >>confdefs.h

+  echo $ac_declaration      >>confdefs.h

+  echo '#endif'             >>confdefs.h

+fi

+

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+ac_ext=c

+ac_cpp='$CPP $CPPFLAGS'

+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_c_compiler_gnu

+DEPDIR="${am__leading_dot}deps"

+

+          ac_config_commands="$ac_config_commands depfiles"

+

+

+am_make=${MAKE-make}

+cat > confinc << 'END'

+am__doit:

+	@echo done

+.PHONY: am__doit

+END

+# If we don't find an include directive, just comment out the code.

+echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5

+echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6

+am__include="#"

+am__quote=

+_am_result=none

+# First try GNU make style include.

+echo "include confinc" > confmf

+# We grep out `Entering directory' and `Leaving directory'

+# messages which can occur if `w' ends up in MAKEFLAGS.

+# In particular we don't look at `^make:' because GNU make might

+# be invoked under some other name (usually "gmake"), in which

+# case it prints its new name instead of `make'.

+if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then

+   am__include=include

+   am__quote=

+   _am_result=GNU

+fi

+# Now try BSD make style include.

+if test "$am__include" = "#"; then

+   echo '.include "confinc"' > confmf

+   if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then

+      am__include=.include

+      am__quote="\""

+      _am_result=BSD

+   fi

+fi

+

+

+echo "$as_me:$LINENO: result: $_am_result" >&5

+echo "${ECHO_T}$_am_result" >&6

+rm -f confinc confmf

+

+# Check whether --enable-dependency-tracking or --disable-dependency-tracking was given.

+if test "${enable_dependency_tracking+set}" = set; then

+  enableval="$enable_dependency_tracking"

+

+fi;

+if test "x$enable_dependency_tracking" != xno; then

+  am_depcomp="$ac_aux_dir/depcomp"

+  AMDEPBACKSLASH='\'

+fi

+

+

+if test "x$enable_dependency_tracking" != xno; then

+  AMDEP_TRUE=

+  AMDEP_FALSE='#'

+else

+  AMDEP_TRUE='#'

+  AMDEP_FALSE=

+fi

+

+

+

+

+depcc="$CC"   am_compiler_list=

+

+echo "$as_me:$LINENO: checking dependency style of $depcc" >&5

+echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6

+if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then

+  # We make a subdir and do the tests there.  Otherwise we can end up

+  # making bogus files that we don't know about and never remove.  For

+  # instance it was reported that on HP-UX the gcc test will end up

+  # making a dummy file named `D' -- because `-MD' means `put the output

+  # in D'.

+  mkdir conftest.dir

+  # Copy depcomp to subdir because otherwise we won't find it if we're

+  # using a relative directory.

+  cp "$am_depcomp" conftest.dir

+  cd conftest.dir

+  # We will build objects and dependencies in a subdirectory because

+  # it helps to detect inapplicable dependency modes.  For instance

+  # both Tru64's cc and ICC support -MD to output dependencies as a

+  # side effect of compilation, but ICC will put the dependencies in

+  # the current directory while Tru64 will put them in the object

+  # directory.

+  mkdir sub

+

+  am_cv_CC_dependencies_compiler_type=none

+  if test "$am_compiler_list" = ""; then

+     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`

+  fi

+  for depmode in $am_compiler_list; do

+    # Setup a source with many dependencies, because some compilers

+    # like to wrap large dependency lists on column 80 (with \), and

+    # we should not choose a depcomp mode which is confused by this.

+    #

+    # We need to recreate these files for each test, as the compiler may

+    # overwrite some of them when testing with obscure command lines.

+    # This happens at least with the AIX C compiler.

+    : > sub/conftest.c

+    for i in 1 2 3 4 5 6; do

+      echo '#include "conftst'$i'.h"' >> sub/conftest.c

+      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with

+      # Solaris 8's {/usr,}/bin/sh.

+      touch sub/conftst$i.h

+    done

+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf

+

+    case $depmode in

+    nosideeffect)

+      # after this tag, mechanisms are not by side-effect, so they'll

+      # only be used when explicitly requested

+      if test "x$enable_dependency_tracking" = xyes; then

+	continue

+      else

+	break

+      fi

+      ;;

+    none) break ;;

+    esac

+    # We check with `-c' and `-o' for the sake of the "dashmstdout"

+    # mode.  It turns out that the SunPro C++ compiler does not properly

+    # handle `-M -o', and we need to detect this.

+    if depmode=$depmode \

+       source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \

+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \

+       $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \

+         >/dev/null 2>conftest.err &&

+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&

+       grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&

+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then

+      # icc doesn't choke on unknown options, it will just issue warnings

+      # or remarks (even with -Werror).  So we grep stderr for any message

+      # that says an option was ignored or not supported.

+      # When given -MP, icc 7.0 and 7.1 complain thusly:

+      #   icc: Command line warning: ignoring option '-M'; no argument required

+      # The diagnosis changed in icc 8.0:

+      #   icc: Command line remark: option '-MP' not supported

+      if (grep 'ignoring option' conftest.err ||

+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else

+        am_cv_CC_dependencies_compiler_type=$depmode

+        break

+      fi

+    fi

+  done

+

+  cd ..

+  rm -rf conftest.dir

+else

+  am_cv_CC_dependencies_compiler_type=none

+fi

+

+fi

+echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5

+echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6

+CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type

+

+

+

+if

+  test "x$enable_dependency_tracking" != xno \

+  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then

+  am__fastdepCC_TRUE=

+  am__fastdepCC_FALSE='#'

+else

+  am__fastdepCC_TRUE='#'

+  am__fastdepCC_FALSE=

+fi

+

+

+ac_ext=c

+ac_cpp='$CPP $CPPFLAGS'

+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_c_compiler_gnu

+echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5

+echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6

+# On Suns, sometimes $CPP names a directory.

+if test -n "$CPP" && test -d "$CPP"; then

+  CPP=

+fi

+if test -z "$CPP"; then

+  if test "${ac_cv_prog_CPP+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+      # Double quotes because CPP needs to be expanded

+    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"

+    do

+      ac_preproc_ok=false

+for ac_c_preproc_warn_flag in '' yes

+do

+  # Use a header file that comes with gcc, so configuring glibc

+  # with a fresh cross-compiler works.

+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

+  # <limits.h> exists even on freestanding compilers.

+  # On the NeXT, cc -E runs the code through the compiler's parser,

+  # not just through cpp. "Syntax error" is here to catch this case.

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#ifdef __STDC__

+# include <limits.h>

+#else

+# include <assert.h>

+#endif

+		     Syntax error

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_c_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  :

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  # Broken: fails on valid input.

+continue

+fi

+rm -f conftest.err conftest.$ac_ext

+

+  # OK, works on sane cases.  Now check whether non-existent headers

+  # can be detected and how.

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <ac_nonexistent.h>

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_c_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  # Broken: success on invalid input.

+continue

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  # Passes both tests.

+ac_preproc_ok=:

+break

+fi

+rm -f conftest.err conftest.$ac_ext

+

+done

+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.

+rm -f conftest.err conftest.$ac_ext

+if $ac_preproc_ok; then

+  break

+fi

+

+    done

+    ac_cv_prog_CPP=$CPP

+

+fi

+  CPP=$ac_cv_prog_CPP

+else

+  ac_cv_prog_CPP=$CPP

+fi

+echo "$as_me:$LINENO: result: $CPP" >&5

+echo "${ECHO_T}$CPP" >&6

+ac_preproc_ok=false

+for ac_c_preproc_warn_flag in '' yes

+do

+  # Use a header file that comes with gcc, so configuring glibc

+  # with a fresh cross-compiler works.

+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

+  # <limits.h> exists even on freestanding compilers.

+  # On the NeXT, cc -E runs the code through the compiler's parser,

+  # not just through cpp. "Syntax error" is here to catch this case.

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#ifdef __STDC__

+# include <limits.h>

+#else

+# include <assert.h>

+#endif

+		     Syntax error

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_c_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  :

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  # Broken: fails on valid input.

+continue

+fi

+rm -f conftest.err conftest.$ac_ext

+

+  # OK, works on sane cases.  Now check whether non-existent headers

+  # can be detected and how.

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <ac_nonexistent.h>

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_c_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  # Broken: success on invalid input.

+continue

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  # Passes both tests.

+ac_preproc_ok=:

+break

+fi

+rm -f conftest.err conftest.$ac_ext

+

+done

+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.

+rm -f conftest.err conftest.$ac_ext

+if $ac_preproc_ok; then

+  :

+else

+  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check

+See \`config.log' for more details." >&5

+echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check

+See \`config.log' for more details." >&2;}

+   { (exit 1); exit 1; }; }

+fi

+

+ac_ext=c

+ac_cpp='$CPP $CPPFLAGS'

+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_c_compiler_gnu

+

+ac_ext=cc

+ac_cpp='$CXXCPP $CPPFLAGS'

+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu

+if test -n "$ac_tool_prefix"; then

+  for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC

+  do

+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.

+set dummy $ac_tool_prefix$ac_prog; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_CXX+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$CXX"; then

+  ac_cv_prog_CXX="$CXX" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+fi

+fi

+CXX=$ac_cv_prog_CXX

+if test -n "$CXX"; then

+  echo "$as_me:$LINENO: result: $CXX" >&5

+echo "${ECHO_T}$CXX" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+    test -n "$CXX" && break

+  done

+fi

+if test -z "$CXX"; then

+  ac_ct_CXX=$CXX

+  for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC

+do

+  # Extract the first word of "$ac_prog", so it can be a program name with args.

+set dummy $ac_prog; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$ac_ct_CXX"; then

+  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_ac_ct_CXX="$ac_prog"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+fi

+fi

+ac_ct_CXX=$ac_cv_prog_ac_ct_CXX

+if test -n "$ac_ct_CXX"; then

+  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5

+echo "${ECHO_T}$ac_ct_CXX" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+  test -n "$ac_ct_CXX" && break

+done

+test -n "$ac_ct_CXX" || ac_ct_CXX="g++"

+

+  CXX=$ac_ct_CXX

+fi

+

+

+# Provide some information about the compiler.

+echo "$as_me:$LINENO:" \

+     "checking for C++ compiler version" >&5

+ac_compiler=`set X $ac_compile; echo $2`

+{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5

+  (eval $ac_compiler --version </dev/null >&5) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }

+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5

+  (eval $ac_compiler -v </dev/null >&5) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }

+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5

+  (eval $ac_compiler -V </dev/null >&5) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }

+

+echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5

+echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6

+if test "${ac_cv_cxx_compiler_gnu+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+int

+main ()

+{

+#ifndef __GNUC__

+       choke me

+#endif

+

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_cxx_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_compiler_gnu=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_compiler_gnu=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+ac_cv_cxx_compiler_gnu=$ac_compiler_gnu

+

+fi

+echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5

+echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6

+GXX=`test $ac_compiler_gnu = yes && echo yes`

+ac_test_CXXFLAGS=${CXXFLAGS+set}

+ac_save_CXXFLAGS=$CXXFLAGS

+CXXFLAGS="-g"

+echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5

+echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6

+if test "${ac_cv_prog_cxx_g+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+int

+main ()

+{

+

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_cxx_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_cv_prog_cxx_g=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_cv_prog_cxx_g=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+fi

+echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5

+echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6

+if test "$ac_test_CXXFLAGS" = set; then

+  CXXFLAGS=$ac_save_CXXFLAGS

+elif test $ac_cv_prog_cxx_g = yes; then

+  if test "$GXX" = yes; then

+    CXXFLAGS="-g -O2"

+  else

+    CXXFLAGS="-g"

+  fi

+else

+  if test "$GXX" = yes; then

+    CXXFLAGS="-O2"

+  else

+    CXXFLAGS=

+  fi

+fi

+for ac_declaration in \

+   '' \

+   'extern "C" void std::exit (int) throw (); using std::exit;' \

+   'extern "C" void std::exit (int); using std::exit;' \

+   'extern "C" void exit (int) throw ();' \

+   'extern "C" void exit (int);' \

+   'void exit (int);'

+do

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_declaration

+#include <stdlib.h>

+int

+main ()

+{

+exit (42);

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_cxx_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  :

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+continue

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_declaration

+int

+main ()

+{

+exit (42);

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_cxx_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  break

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+done

+rm -f conftest*

+if test -n "$ac_declaration"; then

+  echo '#ifdef __cplusplus' >>confdefs.h

+  echo $ac_declaration      >>confdefs.h

+  echo '#endif'             >>confdefs.h

+fi

+

+ac_ext=c

+ac_cpp='$CPP $CPPFLAGS'

+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_c_compiler_gnu

+

+depcc="$CXX"  am_compiler_list=

+

+echo "$as_me:$LINENO: checking dependency style of $depcc" >&5

+echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6

+if test "${am_cv_CXX_dependencies_compiler_type+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then

+  # We make a subdir and do the tests there.  Otherwise we can end up

+  # making bogus files that we don't know about and never remove.  For

+  # instance it was reported that on HP-UX the gcc test will end up

+  # making a dummy file named `D' -- because `-MD' means `put the output

+  # in D'.

+  mkdir conftest.dir

+  # Copy depcomp to subdir because otherwise we won't find it if we're

+  # using a relative directory.

+  cp "$am_depcomp" conftest.dir

+  cd conftest.dir

+  # We will build objects and dependencies in a subdirectory because

+  # it helps to detect inapplicable dependency modes.  For instance

+  # both Tru64's cc and ICC support -MD to output dependencies as a

+  # side effect of compilation, but ICC will put the dependencies in

+  # the current directory while Tru64 will put them in the object

+  # directory.

+  mkdir sub

+

+  am_cv_CXX_dependencies_compiler_type=none

+  if test "$am_compiler_list" = ""; then

+     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`

+  fi

+  for depmode in $am_compiler_list; do

+    # Setup a source with many dependencies, because some compilers

+    # like to wrap large dependency lists on column 80 (with \), and

+    # we should not choose a depcomp mode which is confused by this.

+    #

+    # We need to recreate these files for each test, as the compiler may

+    # overwrite some of them when testing with obscure command lines.

+    # This happens at least with the AIX C compiler.

+    : > sub/conftest.c

+    for i in 1 2 3 4 5 6; do

+      echo '#include "conftst'$i'.h"' >> sub/conftest.c

+      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with

+      # Solaris 8's {/usr,}/bin/sh.

+      touch sub/conftst$i.h

+    done

+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf

+

+    case $depmode in

+    nosideeffect)

+      # after this tag, mechanisms are not by side-effect, so they'll

+      # only be used when explicitly requested

+      if test "x$enable_dependency_tracking" = xyes; then

+	continue

+      else

+	break

+      fi

+      ;;

+    none) break ;;

+    esac

+    # We check with `-c' and `-o' for the sake of the "dashmstdout"

+    # mode.  It turns out that the SunPro C++ compiler does not properly

+    # handle `-M -o', and we need to detect this.

+    if depmode=$depmode \

+       source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \

+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \

+       $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \

+         >/dev/null 2>conftest.err &&

+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&

+       grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&

+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then

+      # icc doesn't choke on unknown options, it will just issue warnings

+      # or remarks (even with -Werror).  So we grep stderr for any message

+      # that says an option was ignored or not supported.

+      # When given -MP, icc 7.0 and 7.1 complain thusly:

+      #   icc: Command line warning: ignoring option '-M'; no argument required

+      # The diagnosis changed in icc 8.0:

+      #   icc: Command line remark: option '-MP' not supported

+      if (grep 'ignoring option' conftest.err ||

+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else

+        am_cv_CXX_dependencies_compiler_type=$depmode

+        break

+      fi

+    fi

+  done

+

+  cd ..

+  rm -rf conftest.dir

+else

+  am_cv_CXX_dependencies_compiler_type=none

+fi

+

+fi

+echo "$as_me:$LINENO: result: $am_cv_CXX_dependencies_compiler_type" >&5

+echo "${ECHO_T}$am_cv_CXX_dependencies_compiler_type" >&6

+CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type

+

+

+

+if

+  test "x$enable_dependency_tracking" != xno \

+  && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then

+  am__fastdepCXX_TRUE=

+  am__fastdepCXX_FALSE='#'

+else

+  am__fastdepCXX_TRUE='#'

+  am__fastdepCXX_FALSE=

+fi

+

+

+

+

+if test "$GCC" = yes; then

+  GCC_TRUE=

+  GCC_FALSE='#'

+else

+  GCC_TRUE='#'

+  GCC_FALSE=

+fi

+   # let the Makefile know if we're gcc

+

+# Check whether --enable-shared or --disable-shared was given.

+if test "${enable_shared+set}" = set; then

+  enableval="$enable_shared"

+  p=${PACKAGE-default}

+    case $enableval in

+    yes) enable_shared=yes ;;

+    no) enable_shared=no ;;

+    *)

+      enable_shared=no

+      # Look at the argument we got.  We use all the common list separators.

+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"

+      for pkg in $enableval; do

+	IFS="$lt_save_ifs"

+	if test "X$pkg" = "X$p"; then

+	  enable_shared=yes

+	fi

+      done

+      IFS="$lt_save_ifs"

+      ;;

+    esac

+else

+  enable_shared=yes

+fi;

+

+# Check whether --enable-static or --disable-static was given.

+if test "${enable_static+set}" = set; then

+  enableval="$enable_static"

+  p=${PACKAGE-default}

+    case $enableval in

+    yes) enable_static=yes ;;

+    no) enable_static=no ;;

+    *)

+     enable_static=no

+      # Look at the argument we got.  We use all the common list separators.

+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"

+      for pkg in $enableval; do

+	IFS="$lt_save_ifs"

+	if test "X$pkg" = "X$p"; then

+	  enable_static=yes

+	fi

+      done

+      IFS="$lt_save_ifs"

+      ;;

+    esac

+else

+  enable_static=yes

+fi;

+

+# Check whether --enable-fast-install or --disable-fast-install was given.

+if test "${enable_fast_install+set}" = set; then

+  enableval="$enable_fast_install"

+  p=${PACKAGE-default}

+    case $enableval in

+    yes) enable_fast_install=yes ;;

+    no) enable_fast_install=no ;;

+    *)

+      enable_fast_install=no

+      # Look at the argument we got.  We use all the common list separators.

+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"

+      for pkg in $enableval; do

+	IFS="$lt_save_ifs"

+	if test "X$pkg" = "X$p"; then

+	  enable_fast_install=yes

+	fi

+      done

+      IFS="$lt_save_ifs"

+      ;;

+    esac

+else

+  enable_fast_install=yes

+fi;

+

+# Make sure we can run config.sub.

+$ac_config_sub sun4 >/dev/null 2>&1 ||

+  { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5

+echo "$as_me: error: cannot run $ac_config_sub" >&2;}

+   { (exit 1); exit 1; }; }

+

+echo "$as_me:$LINENO: checking build system type" >&5

+echo $ECHO_N "checking build system type... $ECHO_C" >&6

+if test "${ac_cv_build+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  ac_cv_build_alias=$build_alias

+test -z "$ac_cv_build_alias" &&

+  ac_cv_build_alias=`$ac_config_guess`

+test -z "$ac_cv_build_alias" &&

+  { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5

+echo "$as_me: error: cannot guess build type; you must specify one" >&2;}

+   { (exit 1); exit 1; }; }

+ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||

+  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5

+echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}

+   { (exit 1); exit 1; }; }

+

+fi

+echo "$as_me:$LINENO: result: $ac_cv_build" >&5

+echo "${ECHO_T}$ac_cv_build" >&6

+build=$ac_cv_build

+build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`

+build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`

+build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`

+

+

+echo "$as_me:$LINENO: checking host system type" >&5

+echo $ECHO_N "checking host system type... $ECHO_C" >&6

+if test "${ac_cv_host+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  ac_cv_host_alias=$host_alias

+test -z "$ac_cv_host_alias" &&

+  ac_cv_host_alias=$ac_cv_build_alias

+ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||

+  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5

+echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}

+   { (exit 1); exit 1; }; }

+

+fi

+echo "$as_me:$LINENO: result: $ac_cv_host" >&5

+echo "${ECHO_T}$ac_cv_host" >&6

+host=$ac_cv_host

+host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`

+host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`

+host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`

+

+

+echo "$as_me:$LINENO: checking for a sed that does not truncate output" >&5

+echo $ECHO_N "checking for a sed that does not truncate output... $ECHO_C" >&6

+if test "${lt_cv_path_SED+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  # Loop through the user's path and test for sed and gsed.

+# Then use that list of sed's as ones to test for truncation.

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for lt_ac_prog in sed gsed; do

+    for ac_exec_ext in '' $ac_executable_extensions; do

+      if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then

+        lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext"

+      fi

+    done

+  done

+done

+lt_ac_max=0

+lt_ac_count=0

+# Add /usr/xpg4/bin/sed as it is typically found on Solaris

+# along with /bin/sed that truncates output.

+for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do

+  test ! -f $lt_ac_sed && continue

+  cat /dev/null > conftest.in

+  lt_ac_count=0

+  echo $ECHO_N "0123456789$ECHO_C" >conftest.in

+  # Check for GNU sed and select it if it is found.

+  if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then

+    lt_cv_path_SED=$lt_ac_sed

+    break

+  fi

+  while true; do

+    cat conftest.in conftest.in >conftest.tmp

+    mv conftest.tmp conftest.in

+    cp conftest.in conftest.nl

+    echo >>conftest.nl

+    $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break

+    cmp -s conftest.out conftest.nl || break

+    # 10000 chars as input seems more than enough

+    test $lt_ac_count -gt 10 && break

+    lt_ac_count=`expr $lt_ac_count + 1`

+    if test $lt_ac_count -gt $lt_ac_max; then

+      lt_ac_max=$lt_ac_count

+      lt_cv_path_SED=$lt_ac_sed

+    fi

+  done

+done

+

+fi

+

+SED=$lt_cv_path_SED

+echo "$as_me:$LINENO: result: $SED" >&5

+echo "${ECHO_T}$SED" >&6

+

+echo "$as_me:$LINENO: checking for egrep" >&5

+echo $ECHO_N "checking for egrep... $ECHO_C" >&6

+if test "${ac_cv_prog_egrep+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if echo a | (grep -E '(a|b)') >/dev/null 2>&1

+    then ac_cv_prog_egrep='grep -E'

+    else ac_cv_prog_egrep='egrep'

+    fi

+fi

+echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5

+echo "${ECHO_T}$ac_cv_prog_egrep" >&6

+ EGREP=$ac_cv_prog_egrep

+

+

+

+# Check whether --with-gnu-ld or --without-gnu-ld was given.

+if test "${with_gnu_ld+set}" = set; then

+  withval="$with_gnu_ld"

+  test "$withval" = no || with_gnu_ld=yes

+else

+  with_gnu_ld=no

+fi;

+ac_prog=ld

+if test "$GCC" = yes; then

+  # Check if gcc -print-prog-name=ld gives a path.

+  echo "$as_me:$LINENO: checking for ld used by $CC" >&5

+echo $ECHO_N "checking for ld used by $CC... $ECHO_C" >&6

+  case $host in

+  *-*-mingw*)

+    # gcc leaves a trailing carriage return which upsets mingw

+    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;

+  *)

+    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;

+  esac

+  case $ac_prog in

+    # Accept absolute paths.

+    [\\/]* | ?:[\\/]*)

+      re_direlt='/[^/][^/]*/\.\./'

+      # Canonicalize the pathname of ld

+      ac_prog=`echo $ac_prog| $SED 's%\\\\%/%g'`

+      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do

+	ac_prog=`echo $ac_prog| $SED "s%$re_direlt%/%"`

+      done

+      test -z "$LD" && LD="$ac_prog"

+      ;;

+  "")

+    # If it fails, then pretend we aren't using GCC.

+    ac_prog=ld

+    ;;

+  *)

+    # If it is relative, then search for the first ld in PATH.

+    with_gnu_ld=unknown

+    ;;

+  esac

+elif test "$with_gnu_ld" = yes; then

+  echo "$as_me:$LINENO: checking for GNU ld" >&5

+echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6

+else

+  echo "$as_me:$LINENO: checking for non-GNU ld" >&5

+echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6

+fi

+if test "${lt_cv_path_LD+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -z "$LD"; then

+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

+  for ac_dir in $PATH; do

+    IFS="$lt_save_ifs"

+    test -z "$ac_dir" && ac_dir=.

+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then

+      lt_cv_path_LD="$ac_dir/$ac_prog"

+      # Check to see if the program is GNU ld.  I'd rather use --version,

+      # but apparently some variants of GNU ld only accept -v.

+      # Break only if it was the GNU/non-GNU ld that we prefer.

+      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in

+      *GNU* | *'with BFD'*)

+	test "$with_gnu_ld" != no && break

+	;;

+      *)

+	test "$with_gnu_ld" != yes && break

+	;;

+      esac

+    fi

+  done

+  IFS="$lt_save_ifs"

+else

+  lt_cv_path_LD="$LD" # Let the user override the test with a path.

+fi

+fi

+

+LD="$lt_cv_path_LD"

+if test -n "$LD"; then

+  echo "$as_me:$LINENO: result: $LD" >&5

+echo "${ECHO_T}$LD" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5

+echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}

+   { (exit 1); exit 1; }; }

+echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5

+echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6

+if test "${lt_cv_prog_gnu_ld+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  # I'd rather use --version here, but apparently some GNU lds only accept -v.

+case `$LD -v 2>&1 </dev/null` in

+*GNU* | *'with BFD'*)

+  lt_cv_prog_gnu_ld=yes

+  ;;

+*)

+  lt_cv_prog_gnu_ld=no

+  ;;

+esac

+fi

+echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5

+echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6

+with_gnu_ld=$lt_cv_prog_gnu_ld

+

+

+echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5

+echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6

+if test "${lt_cv_ld_reload_flag+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  lt_cv_ld_reload_flag='-r'

+fi

+echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5

+echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6

+reload_flag=$lt_cv_ld_reload_flag

+case $reload_flag in

+"" | " "*) ;;

+*) reload_flag=" $reload_flag" ;;

+esac

+reload_cmds='$LD$reload_flag -o $output$reload_objs'

+case $host_os in

+  darwin*)

+    if test "$GCC" = yes; then

+      reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'

+    else

+      reload_cmds='$LD$reload_flag -o $output$reload_objs'

+    fi

+    ;;

+esac

+

+echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5

+echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6

+if test "${lt_cv_path_NM+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$NM"; then

+  # Let the user override the test.

+  lt_cv_path_NM="$NM"

+else

+  lt_nm_to_check="${ac_tool_prefix}nm"

+  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then

+    lt_nm_to_check="$lt_nm_to_check nm"

+  fi

+  for lt_tmp_nm in $lt_nm_to_check; do

+    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

+    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do

+      IFS="$lt_save_ifs"

+      test -z "$ac_dir" && ac_dir=.

+      tmp_nm="$ac_dir/$lt_tmp_nm"

+      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then

+	# Check to see if the nm accepts a BSD-compat flag.

+	# Adding the `sed 1q' prevents false positives on HP-UX, which says:

+	#   nm: unknown option "B" ignored

+	# Tru64's nm complains that /dev/null is an invalid object file

+	case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in

+	*/dev/null* | *'Invalid file or object type'*)

+	  lt_cv_path_NM="$tmp_nm -B"

+	  break

+	  ;;

+	*)

+	  case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in

+	  */dev/null*)

+	    lt_cv_path_NM="$tmp_nm -p"

+	    break

+	    ;;

+	  *)

+	    lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but

+	    continue # so that we can try to find one that supports BSD flags

+	    ;;

+	  esac

+	  ;;

+	esac

+      fi

+    done

+    IFS="$lt_save_ifs"

+  done

+  test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm

+fi

+fi

+echo "$as_me:$LINENO: result: $lt_cv_path_NM" >&5

+echo "${ECHO_T}$lt_cv_path_NM" >&6

+NM="$lt_cv_path_NM"

+

+echo "$as_me:$LINENO: checking whether ln -s works" >&5

+echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6

+LN_S=$as_ln_s

+if test "$LN_S" = "ln -s"; then

+  echo "$as_me:$LINENO: result: yes" >&5

+echo "${ECHO_T}yes" >&6

+else

+  echo "$as_me:$LINENO: result: no, using $LN_S" >&5

+echo "${ECHO_T}no, using $LN_S" >&6

+fi

+

+echo "$as_me:$LINENO: checking how to recognise dependent libraries" >&5

+echo $ECHO_N "checking how to recognise dependent libraries... $ECHO_C" >&6

+if test "${lt_cv_deplibs_check_method+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  lt_cv_file_magic_cmd='$MAGIC_CMD'

+lt_cv_file_magic_test_file=

+lt_cv_deplibs_check_method='unknown'

+# Need to set the preceding variable on all platforms that support

+# interlibrary dependencies.

+# 'none' -- dependencies not supported.

+# `unknown' -- same as none, but documents that we really don't know.

+# 'pass_all' -- all dependencies passed with no checks.

+# 'test_compile' -- check by making test program.

+# 'file_magic [[regex]]' -- check by looking for files in library path

+# which responds to the $file_magic_cmd with a given extended regex.

+# If you have `file' or equivalent on your system and you're not sure

+# whether `pass_all' will *always* work, you probably want this one.

+

+case $host_os in

+aix4* | aix5*)

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+

+beos*)

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+

+bsdi[45]*)

+  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'

+  lt_cv_file_magic_cmd='/usr/bin/file -L'

+  lt_cv_file_magic_test_file=/shlib/libc.so

+  ;;

+

+cygwin*)

+  # func_win32_libid is a shell function defined in ltmain.sh

+  lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'

+  lt_cv_file_magic_cmd='func_win32_libid'

+  ;;

+

+mingw* | pw32*)

+  # Base MSYS/MinGW do not provide the 'file' command needed by

+  # func_win32_libid shell function, so use a weaker test based on 'objdump'.

+  lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'

+  lt_cv_file_magic_cmd='$OBJDUMP -f'

+  ;;

+

+darwin* | rhapsody*)

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+

+freebsd* | kfreebsd*-gnu | dragonfly*)

+  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then

+    case $host_cpu in

+    i*86 )

+      # Not sure whether the presence of OpenBSD here was a mistake.

+      # Let's accept both of them until this is cleared up.

+      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[3-9]86 (compact )?demand paged shared library'

+      lt_cv_file_magic_cmd=/usr/bin/file

+      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`

+      ;;

+    esac

+  else

+    lt_cv_deplibs_check_method=pass_all

+  fi

+  ;;

+

+gnu*)

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+

+hpux10.20* | hpux11*)

+  lt_cv_file_magic_cmd=/usr/bin/file

+  case $host_cpu in

+  ia64*)

+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'

+    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so

+    ;;

+  hppa*64*)

+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - PA-RISC [0-9].[0-9]'

+    lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl

+    ;;

+  *)

+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'

+    lt_cv_file_magic_test_file=/usr/lib/libc.sl

+    ;;

+  esac

+  ;;

+

+interix3*)

+  # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here

+  lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|\.a)$'

+  ;;

+

+irix5* | irix6* | nonstopux*)

+  case $LD in

+  *-32|*"-32 ") libmagic=32-bit;;

+  *-n32|*"-n32 ") libmagic=N32;;

+  *-64|*"-64 ") libmagic=64-bit;;

+  *) libmagic=never-match;;

+  esac

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+

+# This must be Linux ELF.

+linux*)

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+

+netbsd* | netbsdelf*-gnu | knetbsd*-gnu)

+  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then

+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'

+  else

+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|_pic\.a)$'

+  fi

+  ;;

+

+newos6*)

+  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'

+  lt_cv_file_magic_cmd=/usr/bin/file

+  lt_cv_file_magic_test_file=/usr/lib/libnls.so

+  ;;

+

+nto-qnx*)

+  lt_cv_deplibs_check_method=unknown

+  ;;

+

+openbsd*)

+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$'

+  else

+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'

+  fi

+  ;;

+

+osf3* | osf4* | osf5*)

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+

+solaris*)

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+

+sysv4 | sysv4.3*)

+  case $host_vendor in

+  motorola)

+    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'

+    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`

+    ;;

+  ncr)

+    lt_cv_deplibs_check_method=pass_all

+    ;;

+  sequent)

+    lt_cv_file_magic_cmd='/bin/file'

+    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )'

+    ;;

+  sni)

+    lt_cv_file_magic_cmd='/bin/file'

+    lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib"

+    lt_cv_file_magic_test_file=/lib/libc.so

+    ;;

+  siemens)

+    lt_cv_deplibs_check_method=pass_all

+    ;;

+  pc)

+    lt_cv_deplibs_check_method=pass_all

+    ;;

+  esac

+  ;;

+

+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)

+  lt_cv_deplibs_check_method=pass_all

+  ;;

+esac

+

+fi

+echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5

+echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6

+file_magic_cmd=$lt_cv_file_magic_cmd

+deplibs_check_method=$lt_cv_deplibs_check_method

+test -z "$deplibs_check_method" && deplibs_check_method=unknown

+

+

+

+

+# If no C compiler was specified, use CC.

+LTCC=${LTCC-"$CC"}

+

+# If no C compiler flags were specified, use CFLAGS.

+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}

+

+# Allow CC to be a program name with arguments.

+compiler=$CC

+

+

+# Check whether --enable-libtool-lock or --disable-libtool-lock was given.

+if test "${enable_libtool_lock+set}" = set; then

+  enableval="$enable_libtool_lock"

+

+fi;

+test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes

+

+# Some flags need to be propagated to the compiler or linker for good

+# libtool support.

+case $host in

+ia64-*-hpux*)

+  # Find out which ABI we are using.

+  echo 'int i;' > conftest.$ac_ext

+  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; then

+    case `/usr/bin/file conftest.$ac_objext` in

+    *ELF-32*)

+      HPUX_IA64_MODE="32"

+      ;;

+    *ELF-64*)

+      HPUX_IA64_MODE="64"

+      ;;

+    esac

+  fi

+  rm -rf conftest*

+  ;;

+*-*-irix6*)

+  # Find out which ABI we are using.

+  echo '#line 4377 "configure"' > conftest.$ac_ext

+  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; then

+   if test "$lt_cv_prog_gnu_ld" = yes; then

+    case `/usr/bin/file conftest.$ac_objext` in

+    *32-bit*)

+      LD="${LD-ld} -melf32bsmip"

+      ;;

+    *N32*)

+      LD="${LD-ld} -melf32bmipn32"

+      ;;

+    *64-bit*)

+      LD="${LD-ld} -melf64bmip"

+      ;;

+    esac

+   else

+    case `/usr/bin/file conftest.$ac_objext` in

+    *32-bit*)

+      LD="${LD-ld} -32"

+      ;;

+    *N32*)

+      LD="${LD-ld} -n32"

+      ;;

+    *64-bit*)

+      LD="${LD-ld} -64"

+      ;;

+    esac

+   fi

+  fi

+  rm -rf conftest*

+  ;;

+

+x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)

+  # Find out which ABI we are using.

+  echo 'int i;' > conftest.$ac_ext

+  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; then

+    case `/usr/bin/file conftest.o` in

+    *32-bit*)

+      case $host in

+        x86_64-*linux*)

+          LD="${LD-ld} -m elf_i386"

+          ;;

+        ppc64-*linux*|powerpc64-*linux*)

+          LD="${LD-ld} -m elf32ppclinux"

+          ;;

+        s390x-*linux*)

+          LD="${LD-ld} -m elf_s390"

+          ;;

+        sparc64-*linux*)

+          LD="${LD-ld} -m elf32_sparc"

+          ;;

+      esac

+      ;;

+    *64-bit*)

+      case $host in

+        x86_64-*linux*)

+          LD="${LD-ld} -m elf_x86_64"

+          ;;

+        ppc*-*linux*|powerpc*-*linux*)

+          LD="${LD-ld} -m elf64ppc"

+          ;;

+        s390*-*linux*)

+          LD="${LD-ld} -m elf64_s390"

+          ;;

+        sparc*-*linux*)

+          LD="${LD-ld} -m elf64_sparc"

+          ;;

+      esac

+      ;;

+    esac

+  fi

+  rm -rf conftest*

+  ;;

+

+*-*-sco3.2v5*)

+  # On SCO OpenServer 5, we need -belf to get full-featured binaries.

+  SAVE_CFLAGS="$CFLAGS"

+  CFLAGS="$CFLAGS -belf"

+  echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5

+echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6

+if test "${lt_cv_cc_needs_belf+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  ac_ext=c

+ac_cpp='$CPP $CPPFLAGS'

+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_c_compiler_gnu

+

+     cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+int

+main ()

+{

+

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  lt_cv_cc_needs_belf=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+lt_cv_cc_needs_belf=no

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+     ac_ext=c

+ac_cpp='$CPP $CPPFLAGS'

+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_c_compiler_gnu

+

+fi

+echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5

+echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6

+  if test x"$lt_cv_cc_needs_belf" != x"yes"; then

+    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf

+    CFLAGS="$SAVE_CFLAGS"

+  fi

+  ;;

+sparc*-*solaris*)

+  # Find out which ABI we are using.

+  echo 'int i;' > conftest.$ac_ext

+  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; then

+    case `/usr/bin/file conftest.o` in

+    *64-bit*)

+      case $lt_cv_prog_gnu_ld in

+      yes*) LD="${LD-ld} -m elf64_sparc" ;;

+      *)    LD="${LD-ld} -64" ;;

+      esac

+      ;;

+    esac

+  fi

+  rm -rf conftest*

+  ;;

+

+

+esac

+

+need_locks="$enable_libtool_lock"

+

+

+

+echo "$as_me:$LINENO: checking for ANSI C header files" >&5

+echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6

+if test "${ac_cv_header_stdc+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <stdlib.h>

+#include <stdarg.h>

+#include <string.h>

+#include <float.h>

+

+int

+main ()

+{

+

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_cv_header_stdc=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_cv_header_stdc=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+

+if test $ac_cv_header_stdc = yes; then

+  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <string.h>

+

+_ACEOF

+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

+  $EGREP "memchr" >/dev/null 2>&1; then

+  :

+else

+  ac_cv_header_stdc=no

+fi

+rm -f conftest*

+

+fi

+

+if test $ac_cv_header_stdc = yes; then

+  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <stdlib.h>

+

+_ACEOF

+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

+  $EGREP "free" >/dev/null 2>&1; then

+  :

+else

+  ac_cv_header_stdc=no

+fi

+rm -f conftest*

+

+fi

+

+if test $ac_cv_header_stdc = yes; then

+  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.

+  if test "$cross_compiling" = yes; then

+  :

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <ctype.h>

+#if ((' ' & 0x0FF) == 0x020)

+# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')

+# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))

+#else

+# define ISLOWER(c) \

+		   (('a' <= (c) && (c) <= 'i') \

+		     || ('j' <= (c) && (c) <= 'r') \

+		     || ('s' <= (c) && (c) <= 'z'))

+# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))

+#endif

+

+#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))

+int

+main ()

+{

+  int i;

+  for (i = 0; i < 256; i++)

+    if (XOR (islower (i), ISLOWER (i))

+	|| toupper (i) != TOUPPER (i))

+      exit(2);

+  exit (0);

+}

+_ACEOF

+rm -f conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  :

+else

+  echo "$as_me: program exited with status $ac_status" >&5

+echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+( exit $ac_status )

+ac_cv_header_stdc=no

+fi

+rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

+fi

+fi

+fi

+echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5

+echo "${ECHO_T}$ac_cv_header_stdc" >&6

+if test $ac_cv_header_stdc = yes; then

+

+cat >>confdefs.h <<\_ACEOF

+#define STDC_HEADERS 1

+_ACEOF

+

+fi

+

+# On IRIX 5.3, sys/types and inttypes.h are conflicting.

+

+

+

+

+

+

+

+

+

+for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \

+		  inttypes.h stdint.h unistd.h

+do

+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

+echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_includes_default

+

+#include <$ac_header>

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  eval "$as_ac_Header=yes"

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+eval "$as_ac_Header=no"

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+if test `eval echo '${'$as_ac_Header'}'` = yes; then

+  cat >>confdefs.h <<_ACEOF

+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

+_ACEOF

+

+fi

+

+done

+

+

+

+for ac_header in dlfcn.h

+do

+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+else

+  # Is the header compilable?

+echo "$as_me:$LINENO: checking $ac_header usability" >&5

+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_includes_default

+#include <$ac_header>

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_header_compiler=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_header_compiler=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

+echo "${ECHO_T}$ac_header_compiler" >&6

+

+# Is the header present?

+echo "$as_me:$LINENO: checking $ac_header presence" >&5

+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <$ac_header>

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_c_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  ac_header_preproc=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  ac_header_preproc=no

+fi

+rm -f conftest.err conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

+echo "${ECHO_T}$ac_header_preproc" >&6

+

+# So?  What about this header?

+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in

+  yes:no: )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}

+    ac_header_preproc=yes

+    ;;

+  no:yes:* )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5

+echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5

+echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5

+echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5

+echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}

+    (

+      cat <<\_ASBOX

+## ------------------------------------ ##

+## Report this to opensource@google.com ##

+## ------------------------------------ ##

+_ASBOX

+    ) |

+      sed "s/^/$as_me: WARNING:     /" >&2

+    ;;

+esac

+echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  eval "$as_ac_Header=\$ac_header_preproc"

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+

+fi

+if test `eval echo '${'$as_ac_Header'}'` = yes; then

+  cat >>confdefs.h <<_ACEOF

+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

+_ACEOF

+

+fi

+

+done

+

+

+

+if test -n "$CXX" && ( test "X$CXX" != "Xno" &&

+    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||

+    (test "X$CXX" != "Xg++"))) ; then

+  ac_ext=cc

+ac_cpp='$CXXCPP $CPPFLAGS'

+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu

+echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5

+echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6

+if test -z "$CXXCPP"; then

+  if test "${ac_cv_prog_CXXCPP+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+      # Double quotes because CXXCPP needs to be expanded

+    for CXXCPP in "$CXX -E" "/lib/cpp"

+    do

+      ac_preproc_ok=false

+for ac_cxx_preproc_warn_flag in '' yes

+do

+  # Use a header file that comes with gcc, so configuring glibc

+  # with a fresh cross-compiler works.

+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

+  # <limits.h> exists even on freestanding compilers.

+  # On the NeXT, cc -E runs the code through the compiler's parser,

+  # not just through cpp. "Syntax error" is here to catch this case.

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#ifdef __STDC__

+# include <limits.h>

+#else

+# include <assert.h>

+#endif

+		     Syntax error

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_cxx_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  :

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  # Broken: fails on valid input.

+continue

+fi

+rm -f conftest.err conftest.$ac_ext

+

+  # OK, works on sane cases.  Now check whether non-existent headers

+  # can be detected and how.

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <ac_nonexistent.h>

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_cxx_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  # Broken: success on invalid input.

+continue

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  # Passes both tests.

+ac_preproc_ok=:

+break

+fi

+rm -f conftest.err conftest.$ac_ext

+

+done

+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.

+rm -f conftest.err conftest.$ac_ext

+if $ac_preproc_ok; then

+  break

+fi

+

+    done

+    ac_cv_prog_CXXCPP=$CXXCPP

+

+fi

+  CXXCPP=$ac_cv_prog_CXXCPP

+else

+  ac_cv_prog_CXXCPP=$CXXCPP

+fi

+echo "$as_me:$LINENO: result: $CXXCPP" >&5

+echo "${ECHO_T}$CXXCPP" >&6

+ac_preproc_ok=false

+for ac_cxx_preproc_warn_flag in '' yes

+do

+  # Use a header file that comes with gcc, so configuring glibc

+  # with a fresh cross-compiler works.

+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

+  # <limits.h> exists even on freestanding compilers.

+  # On the NeXT, cc -E runs the code through the compiler's parser,

+  # not just through cpp. "Syntax error" is here to catch this case.

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#ifdef __STDC__

+# include <limits.h>

+#else

+# include <assert.h>

+#endif

+		     Syntax error

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_cxx_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  :

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  # Broken: fails on valid input.

+continue

+fi

+rm -f conftest.err conftest.$ac_ext

+

+  # OK, works on sane cases.  Now check whether non-existent headers

+  # can be detected and how.

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <ac_nonexistent.h>

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_cxx_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  # Broken: success on invalid input.

+continue

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  # Passes both tests.

+ac_preproc_ok=:

+break

+fi

+rm -f conftest.err conftest.$ac_ext

+

+done

+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.

+rm -f conftest.err conftest.$ac_ext

+if $ac_preproc_ok; then

+  :

+else

+  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check

+See \`config.log' for more details." >&5

+echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check

+See \`config.log' for more details." >&2;}

+   { (exit 1); exit 1; }; }

+fi

+

+ac_ext=cc

+ac_cpp='$CXXCPP $CPPFLAGS'

+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu

+

+fi

+

+

+ac_ext=f

+ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'

+ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_f77_compiler_gnu

+if test -n "$ac_tool_prefix"; then

+  for ac_prog in g77 f77 xlf frt pgf77 fort77 fl32 af77 f90 xlf90 pgf90 epcf90 f95 fort xlf95 ifc efc pgf95 lf95 gfortran

+  do

+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.

+set dummy $ac_tool_prefix$ac_prog; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_F77+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$F77"; then

+  ac_cv_prog_F77="$F77" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_F77="$ac_tool_prefix$ac_prog"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+fi

+fi

+F77=$ac_cv_prog_F77

+if test -n "$F77"; then

+  echo "$as_me:$LINENO: result: $F77" >&5

+echo "${ECHO_T}$F77" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+    test -n "$F77" && break

+  done

+fi

+if test -z "$F77"; then

+  ac_ct_F77=$F77

+  for ac_prog in g77 f77 xlf frt pgf77 fort77 fl32 af77 f90 xlf90 pgf90 epcf90 f95 fort xlf95 ifc efc pgf95 lf95 gfortran

+do

+  # Extract the first word of "$ac_prog", so it can be a program name with args.

+set dummy $ac_prog; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_ac_ct_F77+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$ac_ct_F77"; then

+  ac_cv_prog_ac_ct_F77="$ac_ct_F77" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_ac_ct_F77="$ac_prog"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+fi

+fi

+ac_ct_F77=$ac_cv_prog_ac_ct_F77

+if test -n "$ac_ct_F77"; then

+  echo "$as_me:$LINENO: result: $ac_ct_F77" >&5

+echo "${ECHO_T}$ac_ct_F77" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+  test -n "$ac_ct_F77" && break

+done

+

+  F77=$ac_ct_F77

+fi

+

+

+# Provide some information about the compiler.

+echo "$as_me:5274:" \

+     "checking for Fortran 77 compiler version" >&5

+ac_compiler=`set X $ac_compile; echo $2`

+{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5

+  (eval $ac_compiler --version </dev/null >&5) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }

+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5

+  (eval $ac_compiler -v </dev/null >&5) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }

+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5

+  (eval $ac_compiler -V </dev/null >&5) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }

+rm -f a.out

+

+# If we don't use `.F' as extension, the preprocessor is not run on the

+# input file.  (Note that this only needs to work for GNU compilers.)

+ac_save_ext=$ac_ext

+ac_ext=F

+echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 77 compiler" >&5

+echo $ECHO_N "checking whether we are using the GNU Fortran 77 compiler... $ECHO_C" >&6

+if test "${ac_cv_f77_compiler_gnu+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+      program main

+#ifndef __GNUC__

+       choke me

+#endif

+

+      end

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_f77_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_compiler_gnu=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_compiler_gnu=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+ac_cv_f77_compiler_gnu=$ac_compiler_gnu

+

+fi

+echo "$as_me:$LINENO: result: $ac_cv_f77_compiler_gnu" >&5

+echo "${ECHO_T}$ac_cv_f77_compiler_gnu" >&6

+ac_ext=$ac_save_ext

+ac_test_FFLAGS=${FFLAGS+set}

+ac_save_FFLAGS=$FFLAGS

+FFLAGS=

+echo "$as_me:$LINENO: checking whether $F77 accepts -g" >&5

+echo $ECHO_N "checking whether $F77 accepts -g... $ECHO_C" >&6

+if test "${ac_cv_prog_f77_g+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  FFLAGS=-g

+cat >conftest.$ac_ext <<_ACEOF

+      program main

+

+      end

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_f77_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_cv_prog_f77_g=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_cv_prog_f77_g=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+

+fi

+echo "$as_me:$LINENO: result: $ac_cv_prog_f77_g" >&5

+echo "${ECHO_T}$ac_cv_prog_f77_g" >&6

+if test "$ac_test_FFLAGS" = set; then

+  FFLAGS=$ac_save_FFLAGS

+elif test $ac_cv_prog_f77_g = yes; then

+  if test "x$ac_cv_f77_compiler_gnu" = xyes; then

+    FFLAGS="-g -O2"

+  else

+    FFLAGS="-g"

+  fi

+else

+  if test "x$ac_cv_f77_compiler_gnu" = xyes; then

+    FFLAGS="-O2"

+  else

+    FFLAGS=

+  fi

+fi

+

+G77=`test $ac_compiler_gnu = yes && echo yes`

+ac_ext=c

+ac_cpp='$CPP $CPPFLAGS'

+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_c_compiler_gnu

+

+

+

+# Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!

+

+# find the maximum length of command line arguments

+echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5

+echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6

+if test "${lt_cv_sys_max_cmd_len+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+    i=0

+  teststring="ABCD"

+

+  case $build_os in

+  msdosdjgpp*)

+    # On DJGPP, this test can blow up pretty badly due to problems in libc

+    # (any single argument exceeding 2000 bytes causes a buffer overrun

+    # during glob expansion).  Even if it were fixed, the result of this

+    # check would be larger than it should be.

+    lt_cv_sys_max_cmd_len=12288;    # 12K is about right

+    ;;

+

+  gnu*)

+    # Under GNU Hurd, this test is not required because there is

+    # no limit to the length of command line arguments.

+    # Libtool will interpret -1 as no limit whatsoever

+    lt_cv_sys_max_cmd_len=-1;

+    ;;

+

+  cygwin* | mingw*)

+    # On Win9x/ME, this test blows up -- it succeeds, but takes

+    # about 5 minutes as the teststring grows exponentially.

+    # Worse, since 9x/ME are not pre-emptively multitasking,

+    # you end up with a "frozen" computer, even though with patience

+    # the test eventually succeeds (with a max line length of 256k).

+    # Instead, let's just punt: use the minimum linelength reported by

+    # all of the supported platforms: 8192 (on NT/2K/XP).

+    lt_cv_sys_max_cmd_len=8192;

+    ;;

+

+  amigaos*)

+    # On AmigaOS with pdksh, this test takes hours, literally.

+    # So we just punt and use a minimum line length of 8192.

+    lt_cv_sys_max_cmd_len=8192;

+    ;;

+

+  netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)

+    # This has been around since 386BSD, at least.  Likely further.

+    if test -x /sbin/sysctl; then

+      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`

+    elif test -x /usr/sbin/sysctl; then

+      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`

+    else

+      lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs

+    fi

+    # And add a safety zone

+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`

+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`

+    ;;

+

+  interix*)

+    # We know the value 262144 and hardcode it with a safety zone (like BSD)

+    lt_cv_sys_max_cmd_len=196608

+    ;;

+

+  osf*)

+    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure

+    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not

+    # nice to cause kernel panics so lets avoid the loop below.

+    # First set a reasonable default.

+    lt_cv_sys_max_cmd_len=16384

+    #

+    if test -x /sbin/sysconfig; then

+      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in

+        *1*) lt_cv_sys_max_cmd_len=-1 ;;

+      esac

+    fi

+    ;;

+  sco3.2v5*)

+    lt_cv_sys_max_cmd_len=102400

+    ;;

+  sysv5* | sco5v6* | sysv4.2uw2*)

+    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`

+    if test -n "$kargmax"; then

+      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[ 	]//'`

+    else

+      lt_cv_sys_max_cmd_len=32768

+    fi

+    ;;

+  *)

+    # If test is not a shell built-in, we'll probably end up computing a

+    # maximum length that is only half of the actual maximum length, but

+    # we can't tell.

+    SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}

+    while (test "X"`$SHELL $0 --fallback-echo "X$teststring" 2>/dev/null` \

+	       = "XX$teststring") >/dev/null 2>&1 &&

+	    new_result=`expr "X$teststring" : ".*" 2>&1` &&

+	    lt_cv_sys_max_cmd_len=$new_result &&

+	    test $i != 17 # 1/2 MB should be enough

+    do

+      i=`expr $i + 1`

+      teststring=$teststring$teststring

+    done

+    teststring=

+    # Add a significant safety factor because C++ compilers can tack on massive

+    # amounts of additional arguments before passing them to the linker.

+    # It appears as though 1/2 is a usable value.

+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`

+    ;;

+  esac

+

+fi

+

+if test -n $lt_cv_sys_max_cmd_len ; then

+  echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5

+echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6

+else

+  echo "$as_me:$LINENO: result: none" >&5

+echo "${ECHO_T}none" >&6

+fi

+

+

+

+

+# Check for command to grab the raw symbol name followed by C symbol from nm.

+echo "$as_me:$LINENO: checking command to parse $NM output from $compiler object" >&5

+echo $ECHO_N "checking command to parse $NM output from $compiler object... $ECHO_C" >&6

+if test "${lt_cv_sys_global_symbol_pipe+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+

+# These are sane defaults that work on at least a few old systems.

+# [They come from Ultrix.  What could be older than Ultrix?!! ;)]

+

+# Character class describing NM global symbol codes.

+symcode='[BCDEGRST]'

+

+# Regexp to match symbols that can be accessed directly from C.

+sympat='\([_A-Za-z][_A-Za-z0-9]*\)'

+

+# Transform an extracted symbol line into a proper C declaration

+lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern int \1;/p'"

+

+# Transform an extracted symbol line into symbol name and symbol address

+lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode \([^ ]*\) \([^ ]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"

+

+# Define system-specific variables.

+case $host_os in

+aix*)

+  symcode='[BCDT]'

+  ;;

+cygwin* | mingw* | pw32*)

+  symcode='[ABCDGISTW]'

+  ;;

+hpux*) # Its linker distinguishes data from code symbols

+  if test "$host_cpu" = ia64; then

+    symcode='[ABCDEGRST]'

+  fi

+  lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"

+  lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"

+  ;;

+linux*)

+  if test "$host_cpu" = ia64; then

+    symcode='[ABCDGIRSTW]'

+    lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"

+    lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"

+  fi

+  ;;

+irix* | nonstopux*)

+  symcode='[BCDEGRST]'

+  ;;

+osf*)

+  symcode='[BCDEGQRST]'

+  ;;

+solaris*)

+  symcode='[BDRT]'

+  ;;

+sco3.2v5*)

+  symcode='[DT]'

+  ;;

+sysv4.2uw2*)

+  symcode='[DT]'

+  ;;

+sysv5* | sco5v6* | unixware* | OpenUNIX*)

+  symcode='[ABDT]'

+  ;;

+sysv4)

+  symcode='[DFNSTU]'

+  ;;

+esac

+

+# Handle CRLF in mingw tool chain

+opt_cr=

+case $build_os in

+mingw*)

+  opt_cr=`echo 'x\{0,1\}' | tr x '\015'` # option cr in regexp

+  ;;

+esac

+

+# If we're using GNU nm, then use its standard symbol codes.

+case `$NM -V 2>&1` in

+*GNU* | *'with BFD'*)

+  symcode='[ABCDGIRSTW]' ;;

+esac

+

+# Try without a prefix undercore, then with it.

+for ac_symprfx in "" "_"; do

+

+  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.

+  symxfrm="\\1 $ac_symprfx\\2 \\2"

+

+  # Write the raw and C identifiers.

+  lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[ 	]\($symcode$symcode*\)[ 	][ 	]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"

+

+  # Check to see that the pipe works correctly.

+  pipe_works=no

+

+  rm -f conftest*

+  cat > conftest.$ac_ext <<EOF

+#ifdef __cplusplus

+extern "C" {

+#endif

+char nm_test_var;

+void nm_test_func(){}

+#ifdef __cplusplus

+}

+#endif

+int main(){nm_test_var='a';nm_test_func();return(0);}

+EOF

+

+  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; then

+    # Now try to grab the symbols.

+    nlist=conftest.nm

+    if { (eval echo "$as_me:$LINENO: \"$NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist\"") >&5

+  (eval $NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } && test -s "$nlist"; then

+      # Try sorting and uniquifying the output.

+      if sort "$nlist" | uniq > "$nlist"T; then

+	mv -f "$nlist"T "$nlist"

+      else

+	rm -f "$nlist"T

+      fi

+

+      # Make sure that we snagged all the symbols we need.

+      if grep ' nm_test_var$' "$nlist" >/dev/null; then

+	if grep ' nm_test_func$' "$nlist" >/dev/null; then

+	  cat <<EOF > conftest.$ac_ext

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+EOF

+	  # Now generate the symbol file.

+	  eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | grep -v main >> conftest.$ac_ext'

+

+	  cat <<EOF >> conftest.$ac_ext

+#if defined (__STDC__) && __STDC__

+# define lt_ptr_t void *

+#else

+# define lt_ptr_t char *

+# define const

+#endif

+

+/* The mapping between symbol names and symbols. */

+const struct {

+  const char *name;

+  lt_ptr_t address;

+}

+lt_preloaded_symbols[] =

+{

+EOF

+	  $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (lt_ptr_t) \&\2},/" < "$nlist" | grep -v main >> conftest.$ac_ext

+	  cat <<\EOF >> conftest.$ac_ext

+  {0, (lt_ptr_t) 0}

+};

+

+#ifdef __cplusplus

+}

+#endif

+EOF

+	  # Now try linking the two files.

+	  mv conftest.$ac_objext conftstm.$ac_objext

+	  lt_save_LIBS="$LIBS"

+	  lt_save_CFLAGS="$CFLAGS"

+	  LIBS="conftstm.$ac_objext"

+	  CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag"

+	  if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } && test -s conftest${ac_exeext}; then

+	    pipe_works=yes

+	  fi

+	  LIBS="$lt_save_LIBS"

+	  CFLAGS="$lt_save_CFLAGS"

+	else

+	  echo "cannot find nm_test_func in $nlist" >&5

+	fi

+      else

+	echo "cannot find nm_test_var in $nlist" >&5

+      fi

+    else

+      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5

+    fi

+  else

+    echo "$progname: failed program was:" >&5

+    cat conftest.$ac_ext >&5

+  fi

+  rm -f conftest* conftst*

+

+  # Do not use the global_symbol_pipe unless it works.

+  if test "$pipe_works" = yes; then

+    break

+  else

+    lt_cv_sys_global_symbol_pipe=

+  fi

+done

+

+fi

+

+if test -z "$lt_cv_sys_global_symbol_pipe"; then

+  lt_cv_sys_global_symbol_to_cdecl=

+fi

+if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then

+  echo "$as_me:$LINENO: result: failed" >&5

+echo "${ECHO_T}failed" >&6

+else

+  echo "$as_me:$LINENO: result: ok" >&5

+echo "${ECHO_T}ok" >&6

+fi

+

+echo "$as_me:$LINENO: checking for objdir" >&5

+echo $ECHO_N "checking for objdir... $ECHO_C" >&6

+if test "${lt_cv_objdir+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  rm -f .libs 2>/dev/null

+mkdir .libs 2>/dev/null

+if test -d .libs; then

+  lt_cv_objdir=.libs

+else

+  # MS-DOS does not allow filenames that begin with a dot.

+  lt_cv_objdir=_libs

+fi

+rmdir .libs 2>/dev/null

+fi

+echo "$as_me:$LINENO: result: $lt_cv_objdir" >&5

+echo "${ECHO_T}$lt_cv_objdir" >&6

+objdir=$lt_cv_objdir

+

+

+

+

+

+case $host_os in

+aix3*)

+  # AIX sometimes has problems with the GCC collect2 program.  For some

+  # reason, if we set the COLLECT_NAMES environment variable, the problems

+  # vanish in a puff of smoke.

+  if test "X${COLLECT_NAMES+set}" != Xset; then

+    COLLECT_NAMES=

+    export COLLECT_NAMES

+  fi

+  ;;

+esac

+

+# Sed substitution that helps us do robust quoting.  It backslashifies

+# metacharacters that are still active within double-quoted strings.

+Xsed='sed -e 1s/^X//'

+sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g'

+

+# Same as above, but do not quote variable references.

+double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g'

+

+# Sed substitution to delay expansion of an escaped shell variable in a

+# double_quote_subst'ed string.

+delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'

+

+# Sed substitution to avoid accidental globbing in evaled expressions

+no_glob_subst='s/\*/\\\*/g'

+

+# Constants:

+rm="rm -f"

+

+# Global variables:

+default_ofile=libtool

+can_build_shared=yes

+

+# All known linkers require a `.a' archive for static linking (except MSVC,

+# which needs '.lib').

+libext=a

+ltmain="$ac_aux_dir/ltmain.sh"

+ofile="$default_ofile"

+with_gnu_ld="$lt_cv_prog_gnu_ld"

+

+if test -n "$ac_tool_prefix"; then

+  # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.

+set dummy ${ac_tool_prefix}ar; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_AR+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$AR"; then

+  ac_cv_prog_AR="$AR" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_AR="${ac_tool_prefix}ar"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+fi

+fi

+AR=$ac_cv_prog_AR

+if test -n "$AR"; then

+  echo "$as_me:$LINENO: result: $AR" >&5

+echo "${ECHO_T}$AR" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+fi

+if test -z "$ac_cv_prog_AR"; then

+  ac_ct_AR=$AR

+  # Extract the first word of "ar", so it can be a program name with args.

+set dummy ar; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_ac_ct_AR+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$ac_ct_AR"; then

+  ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_ac_ct_AR="ar"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+  test -z "$ac_cv_prog_ac_ct_AR" && ac_cv_prog_ac_ct_AR="false"

+fi

+fi

+ac_ct_AR=$ac_cv_prog_ac_ct_AR

+if test -n "$ac_ct_AR"; then

+  echo "$as_me:$LINENO: result: $ac_ct_AR" >&5

+echo "${ECHO_T}$ac_ct_AR" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+  AR=$ac_ct_AR

+else

+  AR="$ac_cv_prog_AR"

+fi

+

+if test -n "$ac_tool_prefix"; then

+  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.

+set dummy ${ac_tool_prefix}ranlib; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_RANLIB+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$RANLIB"; then

+  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+fi

+fi

+RANLIB=$ac_cv_prog_RANLIB

+if test -n "$RANLIB"; then

+  echo "$as_me:$LINENO: result: $RANLIB" >&5

+echo "${ECHO_T}$RANLIB" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+fi

+if test -z "$ac_cv_prog_RANLIB"; then

+  ac_ct_RANLIB=$RANLIB

+  # Extract the first word of "ranlib", so it can be a program name with args.

+set dummy ranlib; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$ac_ct_RANLIB"; then

+  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_ac_ct_RANLIB="ranlib"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"

+fi

+fi

+ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB

+if test -n "$ac_ct_RANLIB"; then

+  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5

+echo "${ECHO_T}$ac_ct_RANLIB" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+  RANLIB=$ac_ct_RANLIB

+else

+  RANLIB="$ac_cv_prog_RANLIB"

+fi

+

+if test -n "$ac_tool_prefix"; then

+  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.

+set dummy ${ac_tool_prefix}strip; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_STRIP+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$STRIP"; then

+  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_STRIP="${ac_tool_prefix}strip"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+fi

+fi

+STRIP=$ac_cv_prog_STRIP

+if test -n "$STRIP"; then

+  echo "$as_me:$LINENO: result: $STRIP" >&5

+echo "${ECHO_T}$STRIP" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+fi

+if test -z "$ac_cv_prog_STRIP"; then

+  ac_ct_STRIP=$STRIP

+  # Extract the first word of "strip", so it can be a program name with args.

+set dummy strip; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$ac_ct_STRIP"; then

+  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_ac_ct_STRIP="strip"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"

+fi

+fi

+ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP

+if test -n "$ac_ct_STRIP"; then

+  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5

+echo "${ECHO_T}$ac_ct_STRIP" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+  STRIP=$ac_ct_STRIP

+else

+  STRIP="$ac_cv_prog_STRIP"

+fi

+

+

+old_CC="$CC"

+old_CFLAGS="$CFLAGS"

+

+# Set sane defaults for various variables

+test -z "$AR" && AR=ar

+test -z "$AR_FLAGS" && AR_FLAGS=cru

+test -z "$AS" && AS=as

+test -z "$CC" && CC=cc

+test -z "$LTCC" && LTCC=$CC

+test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS

+test -z "$DLLTOOL" && DLLTOOL=dlltool

+test -z "$LD" && LD=ld

+test -z "$LN_S" && LN_S="ln -s"

+test -z "$MAGIC_CMD" && MAGIC_CMD=file

+test -z "$NM" && NM=nm

+test -z "$SED" && SED=sed

+test -z "$OBJDUMP" && OBJDUMP=objdump

+test -z "$RANLIB" && RANLIB=:

+test -z "$STRIP" && STRIP=:

+test -z "$ac_objext" && ac_objext=o

+

+# Determine commands to create old-style static archives.

+old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs'

+old_postinstall_cmds='chmod 644 $oldlib'

+old_postuninstall_cmds=

+

+if test -n "$RANLIB"; then

+  case $host_os in

+  openbsd*)

+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$oldlib"

+    ;;

+  *)

+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$oldlib"

+    ;;

+  esac

+  old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"

+fi

+

+for cc_temp in $compiler""; do

+  case $cc_temp in

+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;

+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;

+    \-*) ;;

+    *) break;;

+  esac

+done

+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`

+

+

+# Only perform the check for file, if the check method requires it

+case $deplibs_check_method in

+file_magic*)

+  if test "$file_magic_cmd" = '$MAGIC_CMD'; then

+    echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5

+echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6

+if test "${lt_cv_path_MAGIC_CMD+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  case $MAGIC_CMD in

+[\\/*] |  ?:[\\/]*)

+  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.

+  ;;

+*)

+  lt_save_MAGIC_CMD="$MAGIC_CMD"

+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

+  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"

+  for ac_dir in $ac_dummy; do

+    IFS="$lt_save_ifs"

+    test -z "$ac_dir" && ac_dir=.

+    if test -f $ac_dir/${ac_tool_prefix}file; then

+      lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"

+      if test -n "$file_magic_test_file"; then

+	case $deplibs_check_method in

+	"file_magic "*)

+	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`

+	  MAGIC_CMD="$lt_cv_path_MAGIC_CMD"

+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |

+	    $EGREP "$file_magic_regex" > /dev/null; then

+	    :

+	  else

+	    cat <<EOF 1>&2

+

+*** Warning: the command libtool uses to detect shared libraries,

+*** $file_magic_cmd, produces output that libtool cannot recognize.

+*** The result is that libtool may fail to recognize shared libraries

+*** as such.  This will affect the creation of libtool libraries that

+*** depend on shared libraries, but programs linked with such libtool

+*** libraries will work regardless of this problem.  Nevertheless, you

+*** may want to report the problem to your system manager and/or to

+*** bug-libtool@gnu.org

+

+EOF

+	  fi ;;

+	esac

+      fi

+      break

+    fi

+  done

+  IFS="$lt_save_ifs"

+  MAGIC_CMD="$lt_save_MAGIC_CMD"

+  ;;

+esac

+fi

+

+MAGIC_CMD="$lt_cv_path_MAGIC_CMD"

+if test -n "$MAGIC_CMD"; then

+  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5

+echo "${ECHO_T}$MAGIC_CMD" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+if test -z "$lt_cv_path_MAGIC_CMD"; then

+  if test -n "$ac_tool_prefix"; then

+    echo "$as_me:$LINENO: checking for file" >&5

+echo $ECHO_N "checking for file... $ECHO_C" >&6

+if test "${lt_cv_path_MAGIC_CMD+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  case $MAGIC_CMD in

+[\\/*] |  ?:[\\/]*)

+  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.

+  ;;

+*)

+  lt_save_MAGIC_CMD="$MAGIC_CMD"

+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

+  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"

+  for ac_dir in $ac_dummy; do

+    IFS="$lt_save_ifs"

+    test -z "$ac_dir" && ac_dir=.

+    if test -f $ac_dir/file; then

+      lt_cv_path_MAGIC_CMD="$ac_dir/file"

+      if test -n "$file_magic_test_file"; then

+	case $deplibs_check_method in

+	"file_magic "*)

+	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`

+	  MAGIC_CMD="$lt_cv_path_MAGIC_CMD"

+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |

+	    $EGREP "$file_magic_regex" > /dev/null; then

+	    :

+	  else

+	    cat <<EOF 1>&2

+

+*** Warning: the command libtool uses to detect shared libraries,

+*** $file_magic_cmd, produces output that libtool cannot recognize.

+*** The result is that libtool may fail to recognize shared libraries

+*** as such.  This will affect the creation of libtool libraries that

+*** depend on shared libraries, but programs linked with such libtool

+*** libraries will work regardless of this problem.  Nevertheless, you

+*** may want to report the problem to your system manager and/or to

+*** bug-libtool@gnu.org

+

+EOF

+	  fi ;;

+	esac

+      fi

+      break

+    fi

+  done

+  IFS="$lt_save_ifs"

+  MAGIC_CMD="$lt_save_MAGIC_CMD"

+  ;;

+esac

+fi

+

+MAGIC_CMD="$lt_cv_path_MAGIC_CMD"

+if test -n "$MAGIC_CMD"; then

+  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5

+echo "${ECHO_T}$MAGIC_CMD" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+  else

+    MAGIC_CMD=:

+  fi

+fi

+

+  fi

+  ;;

+esac

+

+enable_dlopen=no

+enable_win32_dll=no

+

+# Check whether --enable-libtool-lock or --disable-libtool-lock was given.

+if test "${enable_libtool_lock+set}" = set; then

+  enableval="$enable_libtool_lock"

+

+fi;

+test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes

+

+

+# Check whether --with-pic or --without-pic was given.

+if test "${with_pic+set}" = set; then

+  withval="$with_pic"

+  pic_mode="$withval"

+else

+  pic_mode=default

+fi;

+test -z "$pic_mode" && pic_mode=default

+

+# Use C for the default configuration in the libtool script

+tagname=

+lt_save_CC="$CC"

+ac_ext=c

+ac_cpp='$CPP $CPPFLAGS'

+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_c_compiler_gnu

+

+

+# Source file extension for C test sources.

+ac_ext=c

+

+# Object file extension for compiled C test sources.

+objext=o

+objext=$objext

+

+# Code to be used in simple compile tests

+lt_simple_compile_test_code="int some_variable = 0;\n"

+

+# Code to be used in simple link tests

+lt_simple_link_test_code='int main(){return(0);}\n'

+

+

+# If no C compiler was specified, use CC.

+LTCC=${LTCC-"$CC"}

+

+# If no C compiler flags were specified, use CFLAGS.

+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}

+

+# Allow CC to be a program name with arguments.

+compiler=$CC

+

+

+# save warnings/boilerplate of simple test code

+ac_outfile=conftest.$ac_objext

+printf "$lt_simple_compile_test_code" >conftest.$ac_ext

+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err

+_lt_compiler_boilerplate=`cat conftest.err`

+$rm conftest*

+

+ac_outfile=conftest.$ac_objext

+printf "$lt_simple_link_test_code" >conftest.$ac_ext

+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err

+_lt_linker_boilerplate=`cat conftest.err`

+$rm conftest*

+

+

+

+lt_prog_compiler_no_builtin_flag=

+

+if test "$GCC" = yes; then

+  lt_prog_compiler_no_builtin_flag=' -fno-builtin'

+

+

+echo "$as_me:$LINENO: checking if $compiler supports -fno-rtti -fno-exceptions" >&5

+echo $ECHO_N "checking if $compiler supports -fno-rtti -fno-exceptions... $ECHO_C" >&6

+if test "${lt_cv_prog_compiler_rtti_exceptions+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  lt_cv_prog_compiler_rtti_exceptions=no

+  ac_outfile=conftest.$ac_objext

+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext

+   lt_compiler_flag="-fno-rtti -fno-exceptions"

+   # Insert the option either (1) after the last *FLAGS variable, or

+   # (2) before a word containing "conftest.", or (3) at the end.

+   # Note that $ac_compile itself does not contain backslashes and begins

+   # with a dollar sign (not a hyphen), so the echo should work correctly.

+   # The option is referenced via a variable to avoid confusing sed.

+   lt_compile=`echo "$ac_compile" | $SED \

+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \

+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \

+   -e 's:$: $lt_compiler_flag:'`

+   (eval echo "\"\$as_me:6335: $lt_compile\"" >&5)

+   (eval "$lt_compile" 2>conftest.err)

+   ac_status=$?

+   cat conftest.err >&5

+   echo "$as_me:6339: \$? = $ac_status" >&5

+   if (exit $ac_status) && test -s "$ac_outfile"; then

+     # The compiler can only warn and ignore the option if not recognized

+     # So say no if there are warnings other than the usual output.

+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp

+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then

+       lt_cv_prog_compiler_rtti_exceptions=yes

+     fi

+   fi

+   $rm conftest*

+

+fi

+echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_rtti_exceptions" >&5

+echo "${ECHO_T}$lt_cv_prog_compiler_rtti_exceptions" >&6

+

+if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then

+    lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions"

+else

+    :

+fi

+

+fi

+

+lt_prog_compiler_wl=

+lt_prog_compiler_pic=

+lt_prog_compiler_static=

+

+echo "$as_me:$LINENO: checking for $compiler option to produce PIC" >&5

+echo $ECHO_N "checking for $compiler option to produce PIC... $ECHO_C" >&6

+

+  if test "$GCC" = yes; then

+    lt_prog_compiler_wl='-Wl,'

+    lt_prog_compiler_static='-static'

+

+    case $host_os in

+      aix*)

+      # All AIX code is PIC.

+      if test "$host_cpu" = ia64; then

+	# AIX 5 now supports IA64 processor

+	lt_prog_compiler_static='-Bstatic'

+      fi

+      ;;

+

+    amigaos*)

+      # FIXME: we need at least 68020 code to build shared libraries, but

+      # adding the `-m68020' flag to GCC prevents building anything better,

+      # like `-m68040'.

+      lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4'

+      ;;

+

+    beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)

+      # PIC is the default for these OSes.

+      ;;

+

+    mingw* | pw32* | os2*)

+      # This hack is so that the source file can tell whether it is being

+      # built for inclusion in a dll (and should export symbols for example).

+      lt_prog_compiler_pic='-DDLL_EXPORT'

+      ;;

+

+    darwin* | rhapsody*)

+      # PIC is the default on this platform

+      # Common symbols not allowed in MH_DYLIB files

+      lt_prog_compiler_pic='-fno-common'

+      ;;

+

+    interix3*)

+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.

+      # Instead, we relocate shared libraries at runtime.

+      ;;

+

+    msdosdjgpp*)

+      # Just because we use GCC doesn't mean we suddenly get shared libraries

+      # on systems that don't support them.

+      lt_prog_compiler_can_build_shared=no

+      enable_shared=no

+      ;;

+

+    sysv4*MP*)

+      if test -d /usr/nec; then

+	lt_prog_compiler_pic=-Kconform_pic

+      fi

+      ;;

+

+    hpux*)

+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but

+      # not for PA HP-UX.

+      case $host_cpu in

+      hppa*64*|ia64*)

+	# +Z the default

+	;;

+      *)

+	lt_prog_compiler_pic='-fPIC'

+	;;

+      esac

+      ;;

+

+    *)

+      lt_prog_compiler_pic='-fPIC'

+      ;;

+    esac

+  else

+    # PORTME Check for flag to pass linker flags through the system compiler.

+    case $host_os in

+    aix*)

+      lt_prog_compiler_wl='-Wl,'

+      if test "$host_cpu" = ia64; then

+	# AIX 5 now supports IA64 processor

+	lt_prog_compiler_static='-Bstatic'

+      else

+	lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp'

+      fi

+      ;;

+      darwin*)

+        # PIC is the default on this platform

+        # Common symbols not allowed in MH_DYLIB files

+       case $cc_basename in

+         xlc*)

+         lt_prog_compiler_pic='-qnocommon'

+         lt_prog_compiler_wl='-Wl,'

+         ;;

+       esac

+       ;;

+

+    mingw* | pw32* | os2*)

+      # This hack is so that the source file can tell whether it is being

+      # built for inclusion in a dll (and should export symbols for example).

+      lt_prog_compiler_pic='-DDLL_EXPORT'

+      ;;

+

+    hpux9* | hpux10* | hpux11*)

+      lt_prog_compiler_wl='-Wl,'

+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but

+      # not for PA HP-UX.

+      case $host_cpu in

+      hppa*64*|ia64*)

+	# +Z the default

+	;;

+      *)

+	lt_prog_compiler_pic='+Z'

+	;;

+      esac

+      # Is there a better lt_prog_compiler_static that works with the bundled CC?

+      lt_prog_compiler_static='${wl}-a ${wl}archive'

+      ;;

+

+    irix5* | irix6* | nonstopux*)

+      lt_prog_compiler_wl='-Wl,'

+      # PIC (with -KPIC) is the default.

+      lt_prog_compiler_static='-non_shared'

+      ;;

+

+    newsos6)

+      lt_prog_compiler_pic='-KPIC'

+      lt_prog_compiler_static='-Bstatic'

+      ;;

+

+    linux*)

+      case $cc_basename in

+      icc* | ecc*)

+	lt_prog_compiler_wl='-Wl,'

+	lt_prog_compiler_pic='-KPIC'

+	lt_prog_compiler_static='-static'

+        ;;

+      pgcc* | pgf77* | pgf90* | pgf95*)

+        # Portland Group compilers (*not* the Pentium gcc compiler,

+	# which looks to be a dead project)

+	lt_prog_compiler_wl='-Wl,'

+	lt_prog_compiler_pic='-fpic'

+	lt_prog_compiler_static='-Bstatic'

+        ;;

+      ccc*)

+        lt_prog_compiler_wl='-Wl,'

+        # All Alpha code is PIC.

+        lt_prog_compiler_static='-non_shared'

+        ;;

+      esac

+      ;;

+

+    osf3* | osf4* | osf5*)

+      lt_prog_compiler_wl='-Wl,'

+      # All OSF/1 code is PIC.

+      lt_prog_compiler_static='-non_shared'

+      ;;

+

+    solaris*)

+      lt_prog_compiler_pic='-KPIC'

+      lt_prog_compiler_static='-Bstatic'

+      case $cc_basename in

+      f77* | f90* | f95*)

+	lt_prog_compiler_wl='-Qoption ld ';;

+      *)

+	lt_prog_compiler_wl='-Wl,';;

+      esac

+      ;;

+

+    sunos4*)

+      lt_prog_compiler_wl='-Qoption ld '

+      lt_prog_compiler_pic='-PIC'

+      lt_prog_compiler_static='-Bstatic'

+      ;;

+

+    sysv4 | sysv4.2uw2* | sysv4.3*)

+      lt_prog_compiler_wl='-Wl,'

+      lt_prog_compiler_pic='-KPIC'

+      lt_prog_compiler_static='-Bstatic'

+      ;;

+

+    sysv4*MP*)

+      if test -d /usr/nec ;then

+	lt_prog_compiler_pic='-Kconform_pic'

+	lt_prog_compiler_static='-Bstatic'

+      fi

+      ;;

+

+    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)

+      lt_prog_compiler_wl='-Wl,'

+      lt_prog_compiler_pic='-KPIC'

+      lt_prog_compiler_static='-Bstatic'

+      ;;

+

+    unicos*)

+      lt_prog_compiler_wl='-Wl,'

+      lt_prog_compiler_can_build_shared=no

+      ;;

+

+    uts4*)

+      lt_prog_compiler_pic='-pic'

+      lt_prog_compiler_static='-Bstatic'

+      ;;

+

+    *)

+      lt_prog_compiler_can_build_shared=no

+      ;;

+    esac

+  fi

+

+echo "$as_me:$LINENO: result: $lt_prog_compiler_pic" >&5

+echo "${ECHO_T}$lt_prog_compiler_pic" >&6

+

+#

+# Check to make sure the PIC flag actually works.

+#

+if test -n "$lt_prog_compiler_pic"; then

+

+echo "$as_me:$LINENO: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5

+echo $ECHO_N "checking if $compiler PIC flag $lt_prog_compiler_pic works... $ECHO_C" >&6

+if test "${lt_prog_compiler_pic_works+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  lt_prog_compiler_pic_works=no

+  ac_outfile=conftest.$ac_objext

+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext

+   lt_compiler_flag="$lt_prog_compiler_pic -DPIC"

+   # Insert the option either (1) after the last *FLAGS variable, or

+   # (2) before a word containing "conftest.", or (3) at the end.

+   # Note that $ac_compile itself does not contain backslashes and begins

+   # with a dollar sign (not a hyphen), so the echo should work correctly.

+   # The option is referenced via a variable to avoid confusing sed.

+   lt_compile=`echo "$ac_compile" | $SED \

+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \

+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \

+   -e 's:$: $lt_compiler_flag:'`

+   (eval echo "\"\$as_me:6603: $lt_compile\"" >&5)

+   (eval "$lt_compile" 2>conftest.err)

+   ac_status=$?

+   cat conftest.err >&5

+   echo "$as_me:6607: \$? = $ac_status" >&5

+   if (exit $ac_status) && test -s "$ac_outfile"; then

+     # The compiler can only warn and ignore the option if not recognized

+     # So say no if there are warnings other than the usual output.

+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp

+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then

+       lt_prog_compiler_pic_works=yes

+     fi

+   fi

+   $rm conftest*

+

+fi

+echo "$as_me:$LINENO: result: $lt_prog_compiler_pic_works" >&5

+echo "${ECHO_T}$lt_prog_compiler_pic_works" >&6

+

+if test x"$lt_prog_compiler_pic_works" = xyes; then

+    case $lt_prog_compiler_pic in

+     "" | " "*) ;;

+     *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;;

+     esac

+else

+    lt_prog_compiler_pic=

+     lt_prog_compiler_can_build_shared=no

+fi

+

+fi

+case $host_os in

+  # For platforms which do not support PIC, -DPIC is meaningless:

+  *djgpp*)

+    lt_prog_compiler_pic=

+    ;;

+  *)

+    lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC"

+    ;;

+esac

+

+#

+# Check to make sure the static flag actually works.

+#

+wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\"

+echo "$as_me:$LINENO: checking if $compiler static flag $lt_tmp_static_flag works" >&5

+echo $ECHO_N "checking if $compiler static flag $lt_tmp_static_flag works... $ECHO_C" >&6

+if test "${lt_prog_compiler_static_works+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  lt_prog_compiler_static_works=no

+   save_LDFLAGS="$LDFLAGS"

+   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"

+   printf "$lt_simple_link_test_code" > conftest.$ac_ext

+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then

+     # The linker can only warn and ignore the option if not recognized

+     # So say no if there are warnings

+     if test -s conftest.err; then

+       # Append any errors to the config.log.

+       cat conftest.err 1>&5

+       $echo "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp

+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

+       if diff conftest.exp conftest.er2 >/dev/null; then

+         lt_prog_compiler_static_works=yes

+       fi

+     else

+       lt_prog_compiler_static_works=yes

+     fi

+   fi

+   $rm conftest*

+   LDFLAGS="$save_LDFLAGS"

+

+fi

+echo "$as_me:$LINENO: result: $lt_prog_compiler_static_works" >&5

+echo "${ECHO_T}$lt_prog_compiler_static_works" >&6

+

+if test x"$lt_prog_compiler_static_works" = xyes; then

+    :

+else

+    lt_prog_compiler_static=

+fi

+

+

+echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5

+echo $ECHO_N "checking if $compiler supports -c -o file.$ac_objext... $ECHO_C" >&6

+if test "${lt_cv_prog_compiler_c_o+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  lt_cv_prog_compiler_c_o=no

+   $rm -r conftest 2>/dev/null

+   mkdir conftest

+   cd conftest

+   mkdir out

+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext

+

+   lt_compiler_flag="-o out/conftest2.$ac_objext"

+   # Insert the option either (1) after the last *FLAGS variable, or

+   # (2) before a word containing "conftest.", or (3) at the end.

+   # Note that $ac_compile itself does not contain backslashes and begins

+   # with a dollar sign (not a hyphen), so the echo should work correctly.

+   lt_compile=`echo "$ac_compile" | $SED \

+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \

+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \

+   -e 's:$: $lt_compiler_flag:'`

+   (eval echo "\"\$as_me:6707: $lt_compile\"" >&5)

+   (eval "$lt_compile" 2>out/conftest.err)

+   ac_status=$?

+   cat out/conftest.err >&5

+   echo "$as_me:6711: \$? = $ac_status" >&5

+   if (exit $ac_status) && test -s out/conftest2.$ac_objext

+   then

+     # The compiler can only warn and ignore the option if not recognized

+     # So say no if there are warnings

+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp

+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2

+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then

+       lt_cv_prog_compiler_c_o=yes

+     fi

+   fi

+   chmod u+w . 2>&5

+   $rm conftest*

+   # SGI C++ compiler will create directory out/ii_files/ for

+   # template instantiation

+   test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files

+   $rm out/* && rmdir out

+   cd ..

+   rmdir conftest

+   $rm conftest*

+

+fi

+echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_c_o" >&5

+echo "${ECHO_T}$lt_cv_prog_compiler_c_o" >&6

+

+

+hard_links="nottested"

+if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then

+  # do not overwrite the value of need_locks provided by the user

+  echo "$as_me:$LINENO: checking if we can lock with hard links" >&5

+echo $ECHO_N "checking if we can lock with hard links... $ECHO_C" >&6

+  hard_links=yes

+  $rm conftest*

+  ln conftest.a conftest.b 2>/dev/null && hard_links=no

+  touch conftest.a

+  ln conftest.a conftest.b 2>&5 || hard_links=no

+  ln conftest.a conftest.b 2>/dev/null && hard_links=no

+  echo "$as_me:$LINENO: result: $hard_links" >&5

+echo "${ECHO_T}$hard_links" >&6

+  if test "$hard_links" = no; then

+    { echo "$as_me:$LINENO: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5

+echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}

+    need_locks=warn

+  fi

+else

+  need_locks=no

+fi

+

+echo "$as_me:$LINENO: checking whether the $compiler linker ($LD) supports shared libraries" >&5

+echo $ECHO_N "checking whether the $compiler linker ($LD) supports shared libraries... $ECHO_C" >&6

+

+  runpath_var=

+  allow_undefined_flag=

+  enable_shared_with_static_runtimes=no

+  archive_cmds=

+  archive_expsym_cmds=

+  old_archive_From_new_cmds=

+  old_archive_from_expsyms_cmds=

+  export_dynamic_flag_spec=

+  whole_archive_flag_spec=

+  thread_safe_flag_spec=

+  hardcode_libdir_flag_spec=

+  hardcode_libdir_flag_spec_ld=

+  hardcode_libdir_separator=

+  hardcode_direct=no

+  hardcode_minus_L=no

+  hardcode_shlibpath_var=unsupported

+  link_all_deplibs=unknown

+  hardcode_automatic=no

+  module_cmds=

+  module_expsym_cmds=

+  always_export_symbols=no

+  export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'

+  # include_expsyms should be a list of space-separated symbols to be *always*

+  # included in the symbol list

+  include_expsyms=

+  # exclude_expsyms can be an extended regexp of symbols to exclude

+  # it will be wrapped by ` (' and `)$', so one must not match beginning or

+  # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',

+  # as well as any symbol that contains `d'.

+  exclude_expsyms="_GLOBAL_OFFSET_TABLE_"

+  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out

+  # platforms (ab)use it in PIC code, but their linkers get confused if

+  # the symbol is explicitly referenced.  Since portable code cannot

+  # rely on this symbol name, it's probably fine to never include it in

+  # preloaded symbol tables.

+  extract_expsyms_cmds=

+  # Just being paranoid about ensuring that cc_basename is set.

+  for cc_temp in $compiler""; do

+  case $cc_temp in

+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;

+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;

+    \-*) ;;

+    *) break;;

+  esac

+done

+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`

+

+  case $host_os in

+  cygwin* | mingw* | pw32*)

+    # FIXME: the MSVC++ port hasn't been tested in a loooong time

+    # When not using gcc, we currently assume that we are using

+    # Microsoft Visual C++.

+    if test "$GCC" != yes; then

+      with_gnu_ld=no

+    fi

+    ;;

+  interix*)

+    # we just hope/assume this is gcc and not c89 (= MSVC++)

+    with_gnu_ld=yes

+    ;;

+  openbsd*)

+    with_gnu_ld=no

+    ;;

+  esac

+

+  ld_shlibs=yes

+  if test "$with_gnu_ld" = yes; then

+    # If archive_cmds runs LD, not CC, wlarc should be empty

+    wlarc='${wl}'

+

+    # Set some defaults for GNU ld with shared library support. These

+    # are reset later if shared libraries are not supported. Putting them

+    # here allows them to be overridden if necessary.

+    runpath_var=LD_RUN_PATH

+    hardcode_libdir_flag_spec='${wl}--rpath ${wl}$libdir'

+    export_dynamic_flag_spec='${wl}--export-dynamic'

+    # ancient GNU ld didn't support --whole-archive et. al.

+    if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then

+	whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'

+      else

+  	whole_archive_flag_spec=

+    fi

+    supports_anon_versioning=no

+    case `$LD -v 2>/dev/null` in

+      *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11

+      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...

+      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...

+      *\ 2.11.*) ;; # other 2.11 versions

+      *) supports_anon_versioning=yes ;;

+    esac

+

+    # See if GNU ld supports shared libraries.

+    case $host_os in

+    aix3* | aix4* | aix5*)

+      # On AIX/PPC, the GNU linker is very broken

+      if test "$host_cpu" != ia64; then

+	ld_shlibs=no

+	cat <<EOF 1>&2

+

+*** Warning: the GNU linker, at least up to release 2.9.1, is reported

+*** to be unable to reliably create shared libraries on AIX.

+*** Therefore, libtool is disabling shared libraries support.  If you

+*** really care for shared libraries, you may want to modify your PATH

+*** so that a non-GNU linker is found, and then restart.

+

+EOF

+      fi

+      ;;

+

+    amigaos*)

+      archive_cmds='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'

+      hardcode_libdir_flag_spec='-L$libdir'

+      hardcode_minus_L=yes

+

+      # Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports

+      # that the semantics of dynamic libraries on AmigaOS, at least up

+      # to version 4, is to share data among multiple programs linked

+      # with the same dynamic library.  Since this doesn't match the

+      # behavior of shared libraries on other platforms, we can't use

+      # them.

+      ld_shlibs=no

+      ;;

+

+    beos*)

+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	allow_undefined_flag=unsupported

+	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc

+	# support --undefined.  This deserves some investigation.  FIXME

+	archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+      else

+	ld_shlibs=no

+      fi

+      ;;

+

+    cygwin* | mingw* | pw32*)

+      # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless,

+      # as there is no search path for DLLs.

+      hardcode_libdir_flag_spec='-L$libdir'

+      allow_undefined_flag=unsupported

+      always_export_symbols=no

+      enable_shared_with_static_runtimes=yes

+      export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS] /s/.* \([^ ]*\)/\1 DATA/'\'' | $SED -e '\''/^[AITW] /s/.* //'\'' | sort | uniq > $export_symbols'

+

+      if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then

+        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'

+	# If the export-symbols file already is a .def file (1st line

+	# is EXPORTS), use it as is; otherwise, prepend...

+	archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then

+	  cp $export_symbols $output_objdir/$soname.def;

+	else

+	  echo EXPORTS > $output_objdir/$soname.def;

+	  cat $export_symbols >> $output_objdir/$soname.def;

+	fi~

+	$CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'

+      else

+	ld_shlibs=no

+      fi

+      ;;

+

+    interix3*)

+      hardcode_direct=no

+      hardcode_shlibpath_var=no

+      hardcode_libdir_flag_spec='${wl}-rpath,$libdir'

+      export_dynamic_flag_spec='${wl}-E'

+      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.

+      # Instead, shared libraries are loaded at an image base (0x10000000 by

+      # default) and relocated if they conflict, which is a slow very memory

+      # consuming and fragmenting process.  To avoid this, we pick a random,

+      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link

+      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.

+      archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'

+      archive_expsym_cmds='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'

+      ;;

+

+    linux*)

+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	tmp_addflag=

+	case $cc_basename,$host_cpu in

+	pgcc*)				# Portland Group C compiler

+	  whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'

+	  tmp_addflag=' $pic_flag'

+	  ;;

+	pgf77* | pgf90* | pgf95*)	# Portland Group f77 and f90 compilers

+	  whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'

+	  tmp_addflag=' $pic_flag -Mnomain' ;;

+	ecc*,ia64* | icc*,ia64*)		# Intel C compiler on ia64

+	  tmp_addflag=' -i_dynamic' ;;

+	efc*,ia64* | ifort*,ia64*)	# Intel Fortran compiler on ia64

+	  tmp_addflag=' -i_dynamic -nofor_main' ;;

+	ifc* | ifort*)			# Intel Fortran compiler

+	  tmp_addflag=' -nofor_main' ;;

+	esac

+	archive_cmds='$CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+

+	if test $supports_anon_versioning = yes; then

+	  archive_expsym_cmds='$echo "{ global:" > $output_objdir/$libname.ver~

+  cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~

+  $echo "local: *; };" >> $output_objdir/$libname.ver~

+	  $CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'

+	fi

+	link_all_deplibs=no

+      else

+	ld_shlibs=no

+      fi

+      ;;

+

+    netbsd* | netbsdelf*-gnu | knetbsd*-gnu)

+      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

+	archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'

+	wlarc=

+      else

+	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+      fi

+      ;;

+

+    solaris*)

+      if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then

+	ld_shlibs=no

+	cat <<EOF 1>&2

+

+*** Warning: The releases 2.8.* of the GNU linker cannot reliably

+*** create shared libraries on Solaris systems.  Therefore, libtool

+*** is disabling shared libraries support.  We urge you to upgrade GNU

+*** binutils to release 2.9.1 or newer.  Another option is to modify

+*** your PATH or compiler configuration so that the native linker is

+*** used, and then restart.

+

+EOF

+      elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+      else

+	ld_shlibs=no

+      fi

+      ;;

+

+    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)

+      case `$LD -v 2>&1` in

+        *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)

+	ld_shlibs=no

+	cat <<_LT_EOF 1>&2

+

+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not

+*** reliably create shared libraries on SCO systems.  Therefore, libtool

+*** is disabling shared libraries support.  We urge you to upgrade GNU

+*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify

+*** your PATH or compiler configuration so that the native linker is

+*** used, and then restart.

+

+_LT_EOF

+	;;

+	*)

+	  if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	    hardcode_libdir_flag_spec='`test -z "$SCOABSPATH" && echo ${wl}-rpath,$libdir`'

+	    archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib'

+	    archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname,-retain-symbols-file,$export_symbols -o $lib'

+	  else

+	    ld_shlibs=no

+	  fi

+	;;

+      esac

+      ;;

+

+    sunos4*)

+      archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'

+      wlarc=

+      hardcode_direct=yes

+      hardcode_shlibpath_var=no

+      ;;

+

+    *)

+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+      else

+	ld_shlibs=no

+      fi

+      ;;

+    esac

+

+    if test "$ld_shlibs" = no; then

+      runpath_var=

+      hardcode_libdir_flag_spec=

+      export_dynamic_flag_spec=

+      whole_archive_flag_spec=

+    fi

+  else

+    # PORTME fill in a description of your system's linker (not GNU ld)

+    case $host_os in

+    aix3*)

+      allow_undefined_flag=unsupported

+      always_export_symbols=yes

+      archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'

+      # Note: this linker hardcodes the directories in LIBPATH if there

+      # are no directories specified by -L.

+      hardcode_minus_L=yes

+      if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then

+	# Neither direct hardcoding nor static linking is supported with a

+	# broken collect2.

+	hardcode_direct=unsupported

+      fi

+      ;;

+

+    aix4* | aix5*)

+      if test "$host_cpu" = ia64; then

+	# On IA64, the linker does run time linking by default, so we don't

+	# have to do anything special.

+	aix_use_runtimelinking=no

+	exp_sym_flag='-Bexport'

+	no_entry_flag=""

+      else

+	# If we're using GNU nm, then we don't want the "-C" option.

+	# -C means demangle to AIX nm, but means don't demangle with GNU nm

+	if $NM -V 2>&1 | grep 'GNU' > /dev/null; then

+	  export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols'

+	else

+	  export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols'

+	fi

+	aix_use_runtimelinking=no

+

+	# Test if we are trying to use run time linking or normal

+	# AIX style linking. If -brtl is somewhere in LDFLAGS, we

+	# need to do runtime linking.

+	case $host_os in aix4.[23]|aix4.[23].*|aix5*)

+	  for ld_flag in $LDFLAGS; do

+  	  if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then

+  	    aix_use_runtimelinking=yes

+  	    break

+  	  fi

+	  done

+	  ;;

+	esac

+

+	exp_sym_flag='-bexport'

+	no_entry_flag='-bnoentry'

+      fi

+

+      # When large executables or shared objects are built, AIX ld can

+      # have problems creating the table of contents.  If linking a library

+      # or program results in "error TOC overflow" add -mminimal-toc to

+      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not

+      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.

+

+      archive_cmds=''

+      hardcode_direct=yes

+      hardcode_libdir_separator=':'

+      link_all_deplibs=yes

+

+      if test "$GCC" = yes; then

+	case $host_os in aix4.[012]|aix4.[012].*)

+	# We only want to do this on AIX 4.2 and lower, the check

+	# below for broken collect2 doesn't work under 4.3+

+	  collect2name=`${CC} -print-prog-name=collect2`

+	  if test -f "$collect2name" && \

+  	   strings "$collect2name" | grep resolve_lib_name >/dev/null

+	  then

+  	  # We have reworked collect2

+  	  hardcode_direct=yes

+	  else

+  	  # We have old collect2

+  	  hardcode_direct=unsupported

+  	  # It fails to find uninstalled libraries when the uninstalled

+  	  # path is not listed in the libpath.  Setting hardcode_minus_L

+  	  # to unsupported forces relinking

+  	  hardcode_minus_L=yes

+  	  hardcode_libdir_flag_spec='-L$libdir'

+  	  hardcode_libdir_separator=

+	  fi

+	  ;;

+	esac

+	shared_flag='-shared'

+	if test "$aix_use_runtimelinking" = yes; then

+	  shared_flag="$shared_flag "'${wl}-G'

+	fi

+      else

+	# not using gcc

+	if test "$host_cpu" = ia64; then

+  	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release

+  	# chokes on -Wl,-G. The following line is correct:

+	  shared_flag='-G'

+	else

+	  if test "$aix_use_runtimelinking" = yes; then

+	    shared_flag='${wl}-G'

+	  else

+	    shared_flag='${wl}-bM:SRE'

+	  fi

+	fi

+      fi

+

+      # It seems that -bexpall does not export symbols beginning with

+      # underscore (_), so it is better to generate a list of symbols to export.

+      always_export_symbols=yes

+      if test "$aix_use_runtimelinking" = yes; then

+	# Warning - without using the other runtime loading flags (-brtl),

+	# -berok will link without error, but may produce a broken library.

+	allow_undefined_flag='-berok'

+       # Determine the default libpath from the value encoded in an empty executable.

+       cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+int

+main ()

+{

+

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+

+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`

+# Check for a 64-bit object if we didn't find anything.

+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`; fi

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi

+

+       hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"

+	archive_expsym_cmds="\$CC"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"

+       else

+	if test "$host_cpu" = ia64; then

+	  hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'

+	  allow_undefined_flag="-z nodefs"

+	  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"

+	else

+	 # Determine the default libpath from the value encoded in an empty executable.

+	 cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+int

+main ()

+{

+

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+

+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`

+# Check for a 64-bit object if we didn't find anything.

+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`; fi

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi

+

+	 hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"

+	  # Warning - without using the other run time loading flags,

+	  # -berok will link without error, but may produce a broken library.

+	  no_undefined_flag=' ${wl}-bernotok'

+	  allow_undefined_flag=' ${wl}-berok'

+	  # Exported symbols can be pulled into shared objects from archives

+	  whole_archive_flag_spec='$convenience'

+	  archive_cmds_need_lc=yes

+	  # This is similar to how AIX traditionally builds its shared libraries.

+	  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'

+	fi

+      fi

+      ;;

+

+    amigaos*)

+      archive_cmds='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'

+      hardcode_libdir_flag_spec='-L$libdir'

+      hardcode_minus_L=yes

+      # see comment about different semantics on the GNU ld section

+      ld_shlibs=no

+      ;;

+

+    bsdi[45]*)

+      export_dynamic_flag_spec=-rdynamic

+      ;;

+

+    cygwin* | mingw* | pw32*)

+      # When not using gcc, we currently assume that we are using

+      # Microsoft Visual C++.

+      # hardcode_libdir_flag_spec is actually meaningless, as there is

+      # no search path for DLLs.

+      hardcode_libdir_flag_spec=' '

+      allow_undefined_flag=unsupported

+      # Tell ltmain to make .lib files, not .a files.

+      libext=lib

+      # Tell ltmain to make .dll files, not .so files.

+      shrext_cmds=".dll"

+      # FIXME: Setting linknames here is a bad hack.

+      archive_cmds='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames='

+      # The linker will automatically build a .lib file if we build a DLL.

+      old_archive_From_new_cmds='true'

+      # FIXME: Should let the user specify the lib program.

+      old_archive_cmds='lib /OUT:$oldlib$oldobjs$old_deplibs'

+      fix_srcfile_path='`cygpath -w "$srcfile"`'

+      enable_shared_with_static_runtimes=yes

+      ;;

+

+    darwin* | rhapsody*)

+      case $host_os in

+        rhapsody* | darwin1.[012])

+         allow_undefined_flag='${wl}-undefined ${wl}suppress'

+         ;;

+       *) # Darwin 1.3 on

+         if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then

+           allow_undefined_flag='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'

+         else

+           case ${MACOSX_DEPLOYMENT_TARGET} in

+             10.[012])

+               allow_undefined_flag='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'

+               ;;

+             10.*)

+               allow_undefined_flag='${wl}-undefined ${wl}dynamic_lookup'

+               ;;

+           esac

+         fi

+         ;;

+      esac

+      archive_cmds_need_lc=no

+      hardcode_direct=no

+      hardcode_automatic=yes

+      hardcode_shlibpath_var=unsupported

+      whole_archive_flag_spec=''

+      link_all_deplibs=yes

+    if test "$GCC" = yes ; then

+    	output_verbose_link_cmd='echo'

+        archive_cmds='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'

+      module_cmds='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'

+      # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds

+      archive_expsym_cmds='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+      module_expsym_cmds='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+    else

+      case $cc_basename in

+        xlc*)

+         output_verbose_link_cmd='echo'

+         archive_cmds='$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'

+         module_cmds='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'

+          # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds

+         archive_expsym_cmds='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+          module_expsym_cmds='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+          ;;

+       *)

+         ld_shlibs=no

+          ;;

+      esac

+    fi

+      ;;

+

+    dgux*)

+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+      hardcode_libdir_flag_spec='-L$libdir'

+      hardcode_shlibpath_var=no

+      ;;

+

+    freebsd1*)

+      ld_shlibs=no

+      ;;

+

+    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor

+    # support.  Future versions do this automatically, but an explicit c++rt0.o

+    # does not break anything, and helps significantly (at the cost of a little

+    # extra space).

+    freebsd2.2*)

+      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'

+      hardcode_libdir_flag_spec='-R$libdir'

+      hardcode_direct=yes

+      hardcode_shlibpath_var=no

+      ;;

+

+    # Unfortunately, older versions of FreeBSD 2 do not have this feature.

+    freebsd2*)

+      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'

+      hardcode_direct=yes

+      hardcode_minus_L=yes

+      hardcode_shlibpath_var=no

+      ;;

+

+    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.

+    freebsd* | dragonfly*)

+      archive_cmds='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'

+      hardcode_libdir_flag_spec='-R$libdir'

+      hardcode_direct=yes

+      hardcode_shlibpath_var=no

+      ;;

+

+    # GNU/kFreeBSD uses gcc -shared to do shared libraries.

+    kfreebsd*-gnu)

+      archive_cmds='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'

+      hardcode_libdir_flag_spec='-R$libdir'

+      hardcode_direct=yes

+      hardcode_shlibpath_var=no

+      link_all_deplibs=no

+      ;;

+

+    hpux9*)

+      if test "$GCC" = yes; then

+	archive_cmds='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

+      else

+	archive_cmds='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

+      fi

+      hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'

+      hardcode_libdir_separator=:

+      hardcode_direct=yes

+

+      # hardcode_minus_L: Not really in the search PATH,

+      # but as the default location of the library.

+      hardcode_minus_L=yes

+      export_dynamic_flag_spec='${wl}-E'

+      ;;

+

+    hpux10*)

+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then

+	archive_cmds='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

+      else

+	archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'

+      fi

+      if test "$with_gnu_ld" = no; then

+	hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'

+	hardcode_libdir_separator=:

+

+	hardcode_direct=yes

+	export_dynamic_flag_spec='${wl}-E'

+

+	# hardcode_minus_L: Not really in the search PATH,

+	# but as the default location of the library.

+	hardcode_minus_L=yes

+      fi

+      ;;

+

+    hpux11*)

+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then

+	case $host_cpu in

+	hppa*64*)

+	  archive_cmds='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	ia64*)

+	  archive_cmds='$CC -shared ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	*)

+	  archive_cmds='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	esac

+      else

+	case $host_cpu in

+	hppa*64*)

+	  archive_cmds='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	ia64*)

+	  archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	*)

+	  archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	esac

+      fi

+      if test "$with_gnu_ld" = no; then

+	hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'

+	hardcode_libdir_separator=:

+

+	case $host_cpu in

+	hppa*64*|ia64*)

+	  hardcode_libdir_flag_spec_ld='+b $libdir'

+	  hardcode_direct=no

+	  hardcode_shlibpath_var=no

+	  ;;

+	*)

+	  hardcode_direct=yes

+	  export_dynamic_flag_spec='${wl}-E'

+

+	  # hardcode_minus_L: Not really in the search PATH,

+	  # but as the default location of the library.

+	  hardcode_minus_L=yes

+	  ;;

+	esac

+      fi

+      ;;

+

+    irix5* | irix6* | nonstopux*)

+      if test "$GCC" = yes; then

+	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+      else

+	archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+	hardcode_libdir_flag_spec_ld='-rpath $libdir'

+      fi

+      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'

+      hardcode_libdir_separator=:

+      link_all_deplibs=yes

+      ;;

+

+    netbsd* | netbsdelf*-gnu | knetbsd*-gnu)

+      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

+	archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out

+      else

+	archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF

+      fi

+      hardcode_libdir_flag_spec='-R$libdir'

+      hardcode_direct=yes

+      hardcode_shlibpath_var=no

+      ;;

+

+    newsos6)

+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+      hardcode_direct=yes

+      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'

+      hardcode_libdir_separator=:

+      hardcode_shlibpath_var=no

+      ;;

+

+    openbsd*)

+      hardcode_direct=yes

+      hardcode_shlibpath_var=no

+      if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

+	archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'

+	hardcode_libdir_flag_spec='${wl}-rpath,$libdir'

+	export_dynamic_flag_spec='${wl}-E'

+      else

+       case $host_os in

+	 openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*)

+	   archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'

+	   hardcode_libdir_flag_spec='-R$libdir'

+	   ;;

+	 *)

+	   archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'

+	   hardcode_libdir_flag_spec='${wl}-rpath,$libdir'

+	   ;;

+       esac

+      fi

+      ;;

+

+    os2*)

+      hardcode_libdir_flag_spec='-L$libdir'

+      hardcode_minus_L=yes

+      allow_undefined_flag=unsupported

+      archive_cmds='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'

+      old_archive_From_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'

+      ;;

+

+    osf3*)

+      if test "$GCC" = yes; then

+	allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'

+	archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+      else

+	allow_undefined_flag=' -expect_unresolved \*'

+	archive_cmds='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+      fi

+      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'

+      hardcode_libdir_separator=:

+      ;;

+

+    osf4* | osf5*)	# as osf3* with the addition of -msym flag

+      if test "$GCC" = yes; then

+	allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'

+	archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+	hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'

+      else

+	allow_undefined_flag=' -expect_unresolved \*'

+	archive_cmds='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+	archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~

+	$LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib~$rm $lib.exp'

+

+	# Both c and cxx compiler support -rpath directly

+	hardcode_libdir_flag_spec='-rpath $libdir'

+      fi

+      hardcode_libdir_separator=:

+      ;;

+

+    solaris*)

+      no_undefined_flag=' -z text'

+      if test "$GCC" = yes; then

+	wlarc='${wl}'

+	archive_cmds='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

+	  $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp'

+      else

+	wlarc=''

+	archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'

+	archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

+  	$LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'

+      fi

+      hardcode_libdir_flag_spec='-R$libdir'

+      hardcode_shlibpath_var=no

+      case $host_os in

+      solaris2.[0-5] | solaris2.[0-5].*) ;;

+      *)

+ 	# The compiler driver will combine linker options so we

+ 	# cannot just pass the convience library names through

+ 	# without $wl, iff we do not link with $LD.

+ 	# Luckily, gcc supports the same syntax we need for Sun Studio.

+ 	# Supported since Solaris 2.6 (maybe 2.5.1?)

+ 	case $wlarc in

+ 	'')

+ 	  whole_archive_flag_spec='-z allextract$convenience -z defaultextract' ;;

+ 	*)

+ 	  whole_archive_flag_spec='${wl}-z ${wl}allextract`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}-z ${wl}defaultextract' ;;

+ 	esac ;;

+      esac

+      link_all_deplibs=yes

+      ;;

+

+    sunos4*)

+      if test "x$host_vendor" = xsequent; then

+	# Use $CC to link under sequent, because it throws in some extra .o

+	# files that make .init and .fini sections work.

+	archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'

+      else

+	archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'

+      fi

+      hardcode_libdir_flag_spec='-L$libdir'

+      hardcode_direct=yes

+      hardcode_minus_L=yes

+      hardcode_shlibpath_var=no

+      ;;

+

+    sysv4)

+      case $host_vendor in

+	sni)

+	  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+	  hardcode_direct=yes # is this really true???

+	;;

+	siemens)

+	  ## LD is ld it makes a PLAMLIB

+	  ## CC just makes a GrossModule.

+	  archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags'

+	  reload_cmds='$CC -r -o $output$reload_objs'

+	  hardcode_direct=no

+        ;;

+	motorola)

+	  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+	  hardcode_direct=no #Motorola manual says yes, but my tests say they lie

+	;;

+      esac

+      runpath_var='LD_RUN_PATH'

+      hardcode_shlibpath_var=no

+      ;;

+

+    sysv4.3*)

+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+      hardcode_shlibpath_var=no

+      export_dynamic_flag_spec='-Bexport'

+      ;;

+

+    sysv4*MP*)

+      if test -d /usr/nec; then

+	archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+	hardcode_shlibpath_var=no

+	runpath_var=LD_RUN_PATH

+	hardcode_runpath_var=yes

+	ld_shlibs=yes

+      fi

+      ;;

+

+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7*)

+      no_undefined_flag='${wl}-z,text'

+      archive_cmds_need_lc=no

+      hardcode_shlibpath_var=no

+      runpath_var='LD_RUN_PATH'

+

+      if test "$GCC" = yes; then

+	archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+      else

+	archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+      fi

+      ;;

+

+    sysv5* | sco3.2v5* | sco5v6*)

+      # Note: We can NOT use -z defs as we might desire, because we do not

+      # link with -lc, and that would cause any symbols used from libc to

+      # always be unresolved, which means just about no library would

+      # ever link correctly.  If we're not using GNU ld we use -z text

+      # though, which does catch some bad symbols but isn't as heavy-handed

+      # as -z defs.

+      no_undefined_flag='${wl}-z,text'

+      allow_undefined_flag='${wl}-z,nodefs'

+      archive_cmds_need_lc=no

+      hardcode_shlibpath_var=no

+      hardcode_libdir_flag_spec='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'

+      hardcode_libdir_separator=':'

+      link_all_deplibs=yes

+      export_dynamic_flag_spec='${wl}-Bexport'

+      runpath_var='LD_RUN_PATH'

+

+      if test "$GCC" = yes; then

+	archive_cmds='$CC -shared ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+      else

+	archive_cmds='$CC -G ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+      fi

+      ;;

+

+    uts4*)

+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+      hardcode_libdir_flag_spec='-L$libdir'

+      hardcode_shlibpath_var=no

+      ;;

+

+    *)

+      ld_shlibs=no

+      ;;

+    esac

+  fi

+

+echo "$as_me:$LINENO: result: $ld_shlibs" >&5

+echo "${ECHO_T}$ld_shlibs" >&6

+test "$ld_shlibs" = no && can_build_shared=no

+

+#

+# Do we need to explicitly link libc?

+#

+case "x$archive_cmds_need_lc" in

+x|xyes)

+  # Assume -lc should be added

+  archive_cmds_need_lc=yes

+

+  if test "$enable_shared" = yes && test "$GCC" = yes; then

+    case $archive_cmds in

+    *'~'*)

+      # FIXME: we may have to deal with multi-command sequences.

+      ;;

+    '$CC '*)

+      # Test whether the compiler implicitly links with -lc since on some

+      # systems, -lgcc has to come before -lc. If gcc already passes -lc

+      # to ld, don't add -lc before -lgcc.

+      echo "$as_me:$LINENO: checking whether -lc should be explicitly linked in" >&5

+echo $ECHO_N "checking whether -lc should be explicitly linked in... $ECHO_C" >&6

+      $rm conftest*

+      printf "$lt_simple_compile_test_code" > conftest.$ac_ext

+

+      if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } 2>conftest.err; then

+        soname=conftest

+        lib=conftest

+        libobjs=conftest.$ac_objext

+        deplibs=

+        wl=$lt_prog_compiler_wl

+	pic_flag=$lt_prog_compiler_pic

+        compiler_flags=-v

+        linker_flags=-v

+        verstring=

+        output_objdir=.

+        libname=conftest

+        lt_save_allow_undefined_flag=$allow_undefined_flag

+        allow_undefined_flag=

+        if { (eval echo "$as_me:$LINENO: \"$archive_cmds 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\"") >&5

+  (eval $archive_cmds 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }

+        then

+	  archive_cmds_need_lc=no

+        else

+	  archive_cmds_need_lc=yes

+        fi

+        allow_undefined_flag=$lt_save_allow_undefined_flag

+      else

+        cat conftest.err 1>&5

+      fi

+      $rm conftest*

+      echo "$as_me:$LINENO: result: $archive_cmds_need_lc" >&5

+echo "${ECHO_T}$archive_cmds_need_lc" >&6

+      ;;

+    esac

+  fi

+  ;;

+esac

+

+echo "$as_me:$LINENO: checking dynamic linker characteristics" >&5

+echo $ECHO_N "checking dynamic linker characteristics... $ECHO_C" >&6

+library_names_spec=

+libname_spec='lib$name'

+soname_spec=

+shrext_cmds=".so"

+postinstall_cmds=

+postuninstall_cmds=

+finish_cmds=

+finish_eval=

+shlibpath_var=

+shlibpath_overrides_runpath=unknown

+version_type=none

+dynamic_linker="$host_os ld.so"

+sys_lib_dlsearch_path_spec="/lib /usr/lib"

+if test "$GCC" = yes; then

+  sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`

+  if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then

+    # if the path contains ";" then we assume it to be the separator

+    # otherwise default to the standard path separator (i.e. ":") - it is

+    # assumed that no part of a normal pathname contains ";" but that should

+    # okay in the real world where ";" in dirpaths is itself problematic.

+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`

+  else

+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`

+  fi

+else

+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"

+fi

+need_lib_prefix=unknown

+hardcode_into_libs=no

+

+# when you set need_version to no, make sure it does not cause -set_version

+# flags to be left without arguments

+need_version=unknown

+

+case $host_os in

+aix3*)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'

+  shlibpath_var=LIBPATH

+

+  # AIX 3 has no versioning support, so we append a major version to the name.

+  soname_spec='${libname}${release}${shared_ext}$major'

+  ;;

+

+aix4* | aix5*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  hardcode_into_libs=yes

+  if test "$host_cpu" = ia64; then

+    # AIX 5 supports IA64

+    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'

+    shlibpath_var=LD_LIBRARY_PATH

+  else

+    # With GCC up to 2.95.x, collect2 would create an import file

+    # for dependence libraries.  The import file would start with

+    # the line `#! .'.  This would cause the generated library to

+    # depend on `.', always an invalid library.  This was fixed in

+    # development snapshots of GCC prior to 3.0.

+    case $host_os in

+      aix4 | aix4.[01] | aix4.[01].*)

+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'

+	   echo ' yes '

+	   echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then

+	:

+      else

+	can_build_shared=no

+      fi

+      ;;

+    esac

+    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct

+    # soname into executable. Probably we can add versioning support to

+    # collect2, so additional links can be useful in future.

+    if test "$aix_use_runtimelinking" = yes; then

+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so

+      # instead of lib<name>.a to let people know that these are not

+      # typical AIX shared libraries.

+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+    else

+      # We preserve .a as extension for shared libraries through AIX4.2

+      # and later when we are not doing run time linking.

+      library_names_spec='${libname}${release}.a $libname.a'

+      soname_spec='${libname}${release}${shared_ext}$major'

+    fi

+    shlibpath_var=LIBPATH

+  fi

+  ;;

+

+amigaos*)

+  library_names_spec='$libname.ixlibrary $libname.a'

+  # Create ${libname}_ixlibrary.a entries in /sys/libs.

+  finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'

+  ;;

+

+beos*)

+  library_names_spec='${libname}${shared_ext}'

+  dynamic_linker="$host_os ld.so"

+  shlibpath_var=LIBRARY_PATH

+  ;;

+

+bsdi[45]*)

+  version_type=linux

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"

+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"

+  # the default ld.so.conf also contains /usr/contrib/lib and

+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow

+  # libtool to hard-code these into programs

+  ;;

+

+cygwin* | mingw* | pw32*)

+  version_type=windows

+  shrext_cmds=".dll"

+  need_version=no

+  need_lib_prefix=no

+

+  case $GCC,$host_os in

+  yes,cygwin* | yes,mingw* | yes,pw32*)

+    library_names_spec='$libname.dll.a'

+    # DLL is installed to $(libdir)/../bin by postinstall_cmds

+    postinstall_cmds='base_file=`basename \${file}`~

+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~

+      dldir=$destdir/`dirname \$dlpath`~

+      test -d \$dldir || mkdir -p \$dldir~

+      $install_prog $dir/$dlname \$dldir/$dlname~

+      chmod a+x \$dldir/$dlname'

+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~

+      dlpath=$dir/\$dldll~

+       $rm \$dlpath'

+    shlibpath_overrides_runpath=yes

+

+    case $host_os in

+    cygwin*)

+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'

+      soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'

+      sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"

+      ;;

+    mingw*)

+      # MinGW DLLs use traditional 'lib' prefix

+      soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'

+      sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`

+      if echo "$sys_lib_search_path_spec" | grep ';[c-zC-Z]:/' >/dev/null; then

+        # It is most probably a Windows format PATH printed by

+        # mingw gcc, but we are running on Cygwin. Gcc prints its search

+        # path with ; separators, and with drive letters. We can handle the

+        # drive letters (cygwin fileutils understands them), so leave them,

+        # especially as we might pass files found there to a mingw objdump,

+        # which wouldn't understand a cygwinified path. Ahh.

+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`

+      else

+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`

+      fi

+      ;;

+    pw32*)

+      # pw32 DLLs use 'pw' prefix rather than 'lib'

+      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'

+      ;;

+    esac

+    ;;

+

+  *)

+    library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib'

+    ;;

+  esac

+  dynamic_linker='Win32 ld.exe'

+  # FIXME: first we should search . and the directory the executable is in

+  shlibpath_var=PATH

+  ;;

+

+darwin* | rhapsody*)

+  dynamic_linker="$host_os dyld"

+  version_type=darwin

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext'

+  soname_spec='${libname}${release}${major}$shared_ext'

+  shlibpath_overrides_runpath=yes

+  shlibpath_var=DYLD_LIBRARY_PATH

+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'

+  # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same.

+  if test "$GCC" = yes; then

+    sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"`

+  else

+    sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib'

+  fi

+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'

+  ;;

+

+dgux*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  ;;

+

+freebsd1*)

+  dynamic_linker=no

+  ;;

+

+kfreebsd*-gnu)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  dynamic_linker='GNU ld.so'

+  ;;

+

+freebsd* | dragonfly*)

+  # DragonFly does not have aout.  When/if they implement a new

+  # versioning mechanism, adjust this.

+  if test -x /usr/bin/objformat; then

+    objformat=`/usr/bin/objformat`

+  else

+    case $host_os in

+    freebsd[123]*) objformat=aout ;;

+    *) objformat=elf ;;

+    esac

+  fi

+  version_type=freebsd-$objformat

+  case $version_type in

+    freebsd-elf*)

+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'

+      need_version=no

+      need_lib_prefix=no

+      ;;

+    freebsd-*)

+      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'

+      need_version=yes

+      ;;

+  esac

+  shlibpath_var=LD_LIBRARY_PATH

+  case $host_os in

+  freebsd2*)

+    shlibpath_overrides_runpath=yes

+    ;;

+  freebsd3.[01]* | freebsdelf3.[01]*)

+    shlibpath_overrides_runpath=yes

+    hardcode_into_libs=yes

+    ;;

+  freebsd3.[2-9]* | freebsdelf3.[2-9]* | \

+  freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)

+    shlibpath_overrides_runpath=no

+    hardcode_into_libs=yes

+    ;;

+  freebsd*) # from 4.6 on

+    shlibpath_overrides_runpath=yes

+    hardcode_into_libs=yes

+    ;;

+  esac

+  ;;

+

+gnu*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  hardcode_into_libs=yes

+  ;;

+

+hpux9* | hpux10* | hpux11*)

+  # Give a soname corresponding to the major version so that dld.sl refuses to

+  # link against other versions.

+  version_type=sunos

+  need_lib_prefix=no

+  need_version=no

+  case $host_cpu in

+  ia64*)

+    shrext_cmds='.so'

+    hardcode_into_libs=yes

+    dynamic_linker="$host_os dld.so"

+    shlibpath_var=LD_LIBRARY_PATH

+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+    soname_spec='${libname}${release}${shared_ext}$major'

+    if test "X$HPUX_IA64_MODE" = X32; then

+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"

+    else

+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"

+    fi

+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec

+    ;;

+   hppa*64*)

+     shrext_cmds='.sl'

+     hardcode_into_libs=yes

+     dynamic_linker="$host_os dld.sl"

+     shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH

+     shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.

+     library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+     soname_spec='${libname}${release}${shared_ext}$major'

+     sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"

+     sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec

+     ;;

+   *)

+    shrext_cmds='.sl'

+    dynamic_linker="$host_os dld.sl"

+    shlibpath_var=SHLIB_PATH

+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+    soname_spec='${libname}${release}${shared_ext}$major'

+    ;;

+  esac

+  # HP-UX runs *really* slowly unless shared libraries are mode 555.

+  postinstall_cmds='chmod 555 $lib'

+  ;;

+

+interix3*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  ;;

+

+irix5* | irix6* | nonstopux*)

+  case $host_os in

+    nonstopux*) version_type=nonstopux ;;

+    *)

+	if test "$lt_cv_prog_gnu_ld" = yes; then

+		version_type=linux

+	else

+		version_type=irix

+	fi ;;

+  esac

+  need_lib_prefix=no

+  need_version=no

+  soname_spec='${libname}${release}${shared_ext}$major'

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'

+  case $host_os in

+  irix5* | nonstopux*)

+    libsuff= shlibsuff=

+    ;;

+  *)

+    case $LD in # libtool.m4 will add one of these switches to LD

+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")

+      libsuff= shlibsuff= libmagic=32-bit;;

+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")

+      libsuff=32 shlibsuff=N32 libmagic=N32;;

+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")

+      libsuff=64 shlibsuff=64 libmagic=64-bit;;

+    *) libsuff= shlibsuff= libmagic=never-match;;

+    esac

+    ;;

+  esac

+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH

+  shlibpath_overrides_runpath=no

+  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"

+  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"

+  hardcode_into_libs=yes

+  ;;

+

+# No shared lib support for Linux oldld, aout, or coff.

+linux*oldld* | linux*aout* | linux*coff*)

+  dynamic_linker=no

+  ;;

+

+# This must be Linux ELF.

+linux*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  # This implies no fast_install, which is unacceptable.

+  # Some rework will be needed to allow for fast_install

+  # before this can be enabled.

+  hardcode_into_libs=yes

+

+  # Append ld.so.conf contents to the search path

+  if test -f /etc/ld.so.conf; then

+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;/^$/d' | tr '\n' ' '`

+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"

+  fi

+

+  # We used to test for /lib/ld.so.1 and disable shared libraries on

+  # powerpc, because MkLinux only supported shared libraries with the

+  # GNU dynamic linker.  Since this was broken with cross compilers,

+  # most powerpc-linux boxes support dynamic linking these days and

+  # people can always --disable-shared, the test was removed, and we

+  # assume the GNU/Linux dynamic linker is in use.

+  dynamic_linker='GNU/Linux ld.so'

+  ;;

+

+netbsdelf*-gnu)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  dynamic_linker='NetBSD ld.elf_so'

+  ;;

+

+knetbsd*-gnu)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  dynamic_linker='GNU ld.so'

+  ;;

+

+netbsd*)

+  version_type=sunos

+  need_lib_prefix=no

+  need_version=no

+  if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'

+    dynamic_linker='NetBSD (a.out) ld.so'

+  else

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+    soname_spec='${libname}${release}${shared_ext}$major'

+    dynamic_linker='NetBSD ld.elf_so'

+  fi

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  hardcode_into_libs=yes

+  ;;

+

+newsos6)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  ;;

+

+nto-qnx*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  ;;

+

+openbsd*)

+  version_type=sunos

+  sys_lib_dlsearch_path_spec="/usr/lib"

+  need_lib_prefix=no

+  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.

+  case $host_os in

+    openbsd3.3 | openbsd3.3.*) need_version=yes ;;

+    *)                         need_version=no  ;;

+  esac

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

+    case $host_os in

+      openbsd2.[89] | openbsd2.[89].*)

+	shlibpath_overrides_runpath=no

+	;;

+      *)

+	shlibpath_overrides_runpath=yes

+	;;

+      esac

+  else

+    shlibpath_overrides_runpath=yes

+  fi

+  ;;

+

+os2*)

+  libname_spec='$name'

+  shrext_cmds=".dll"

+  need_lib_prefix=no

+  library_names_spec='$libname${shared_ext} $libname.a'

+  dynamic_linker='OS/2 ld.exe'

+  shlibpath_var=LIBPATH

+  ;;

+

+osf3* | osf4* | osf5*)

+  version_type=osf

+  need_lib_prefix=no

+  need_version=no

+  soname_spec='${libname}${release}${shared_ext}$major'

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  shlibpath_var=LD_LIBRARY_PATH

+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"

+  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"

+  ;;

+

+solaris*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  hardcode_into_libs=yes

+  # ldd complains unless libraries are executable

+  postinstall_cmds='chmod +x $lib'

+  ;;

+

+sunos4*)

+  version_type=sunos

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  if test "$with_gnu_ld" = yes; then

+    need_lib_prefix=no

+  fi

+  need_version=yes

+  ;;

+

+sysv4 | sysv4.3*)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  case $host_vendor in

+    sni)

+      shlibpath_overrides_runpath=no

+      need_lib_prefix=no

+      export_dynamic_flag_spec='${wl}-Blargedynsym'

+      runpath_var=LD_RUN_PATH

+      ;;

+    siemens)

+      need_lib_prefix=no

+      ;;

+    motorola)

+      need_lib_prefix=no

+      need_version=no

+      shlibpath_overrides_runpath=no

+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'

+      ;;

+  esac

+  ;;

+

+sysv4*MP*)

+  if test -d /usr/nec ;then

+    version_type=linux

+    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'

+    soname_spec='$libname${shared_ext}.$major'

+    shlibpath_var=LD_LIBRARY_PATH

+  fi

+  ;;

+

+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)

+  version_type=freebsd-elf

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  hardcode_into_libs=yes

+  if test "$with_gnu_ld" = yes; then

+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'

+    shlibpath_overrides_runpath=no

+  else

+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'

+    shlibpath_overrides_runpath=yes

+    case $host_os in

+      sco3.2v5*)

+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"

+	;;

+    esac

+  fi

+  sys_lib_dlsearch_path_spec='/usr/lib'

+  ;;

+

+uts4*)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  ;;

+

+*)

+  dynamic_linker=no

+  ;;

+esac

+echo "$as_me:$LINENO: result: $dynamic_linker" >&5

+echo "${ECHO_T}$dynamic_linker" >&6

+test "$dynamic_linker" = no && can_build_shared=no

+

+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"

+if test "$GCC" = yes; then

+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"

+fi

+

+echo "$as_me:$LINENO: checking how to hardcode library paths into programs" >&5

+echo $ECHO_N "checking how to hardcode library paths into programs... $ECHO_C" >&6

+hardcode_action=

+if test -n "$hardcode_libdir_flag_spec" || \

+   test -n "$runpath_var" || \

+   test "X$hardcode_automatic" = "Xyes" ; then

+

+  # We can hardcode non-existant directories.

+  if test "$hardcode_direct" != no &&

+     # If the only mechanism to avoid hardcoding is shlibpath_var, we

+     # have to relink, otherwise we might link with an installed library

+     # when we should be linking with a yet-to-be-installed one

+     ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, )" != no &&

+     test "$hardcode_minus_L" != no; then

+    # Linking always hardcodes the temporary library directory.

+    hardcode_action=relink

+  else

+    # We can link without hardcoding, and we can hardcode nonexisting dirs.

+    hardcode_action=immediate

+  fi

+else

+  # We cannot hardcode anything, or else we can only hardcode existing

+  # directories.

+  hardcode_action=unsupported

+fi

+echo "$as_me:$LINENO: result: $hardcode_action" >&5

+echo "${ECHO_T}$hardcode_action" >&6

+

+if test "$hardcode_action" = relink; then

+  # Fast installation is not supported

+  enable_fast_install=no

+elif test "$shlibpath_overrides_runpath" = yes ||

+     test "$enable_shared" = no; then

+  # Fast installation is not necessary

+  enable_fast_install=needless

+fi

+

+striplib=

+old_striplib=

+echo "$as_me:$LINENO: checking whether stripping libraries is possible" >&5

+echo $ECHO_N "checking whether stripping libraries is possible... $ECHO_C" >&6

+if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then

+  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"

+  test -z "$striplib" && striplib="$STRIP --strip-unneeded"

+  echo "$as_me:$LINENO: result: yes" >&5

+echo "${ECHO_T}yes" >&6

+else

+# FIXME - insert some real tests, host_os isn't really good enough

+  case $host_os in

+   darwin*)

+       if test -n "$STRIP" ; then

+         striplib="$STRIP -x"

+         echo "$as_me:$LINENO: result: yes" >&5

+echo "${ECHO_T}yes" >&6

+       else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+       ;;

+   *)

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+    ;;

+  esac

+fi

+

+if test "x$enable_dlopen" != xyes; then

+  enable_dlopen=unknown

+  enable_dlopen_self=unknown

+  enable_dlopen_self_static=unknown

+else

+  lt_cv_dlopen=no

+  lt_cv_dlopen_libs=

+

+  case $host_os in

+  beos*)

+    lt_cv_dlopen="load_add_on"

+    lt_cv_dlopen_libs=

+    lt_cv_dlopen_self=yes

+    ;;

+

+  mingw* | pw32*)

+    lt_cv_dlopen="LoadLibrary"

+    lt_cv_dlopen_libs=

+   ;;

+

+  cygwin*)

+    lt_cv_dlopen="dlopen"

+    lt_cv_dlopen_libs=

+   ;;

+

+  darwin*)

+  # if libdl is installed we need to link against it

+    echo "$as_me:$LINENO: checking for dlopen in -ldl" >&5

+echo $ECHO_N "checking for dlopen in -ldl... $ECHO_C" >&6

+if test "${ac_cv_lib_dl_dlopen+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  ac_check_lib_save_LIBS=$LIBS

+LIBS="-ldl  $LIBS"

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+/* Override any gcc2 internal prototype to avoid an error.  */

+#ifdef __cplusplus

+extern "C"

+#endif

+/* We use char because int might match the return type of a gcc2

+   builtin and then its argument prototype would still apply.  */

+char dlopen ();

+int

+main ()

+{

+dlopen ();

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_cv_lib_dl_dlopen=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_cv_lib_dl_dlopen=no

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+LIBS=$ac_check_lib_save_LIBS

+fi

+echo "$as_me:$LINENO: result: $ac_cv_lib_dl_dlopen" >&5

+echo "${ECHO_T}$ac_cv_lib_dl_dlopen" >&6

+if test $ac_cv_lib_dl_dlopen = yes; then

+  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"

+else

+

+    lt_cv_dlopen="dyld"

+    lt_cv_dlopen_libs=

+    lt_cv_dlopen_self=yes

+

+fi

+

+   ;;

+

+  *)

+    echo "$as_me:$LINENO: checking for shl_load" >&5

+echo $ECHO_N "checking for shl_load... $ECHO_C" >&6

+if test "${ac_cv_func_shl_load+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+/* Define shl_load to an innocuous variant, in case <limits.h> declares shl_load.

+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */

+#define shl_load innocuous_shl_load

+

+/* System header to define __stub macros and hopefully few prototypes,

+    which can conflict with char shl_load (); below.

+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

+    <limits.h> exists even on freestanding compilers.  */

+

+#ifdef __STDC__

+# include <limits.h>

+#else

+# include <assert.h>

+#endif

+

+#undef shl_load

+

+/* Override any gcc2 internal prototype to avoid an error.  */

+#ifdef __cplusplus

+extern "C"

+{

+#endif

+/* We use char because int might match the return type of a gcc2

+   builtin and then its argument prototype would still apply.  */

+char shl_load ();

+/* The GNU C library defines this for functions which it implements

+    to always fail with ENOSYS.  Some functions are actually named

+    something starting with __ and the normal name is an alias.  */

+#if defined (__stub_shl_load) || defined (__stub___shl_load)

+choke me

+#else

+char (*f) () = shl_load;

+#endif

+#ifdef __cplusplus

+}

+#endif

+

+int

+main ()

+{

+return f != shl_load;

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_cv_func_shl_load=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_cv_func_shl_load=no

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+fi

+echo "$as_me:$LINENO: result: $ac_cv_func_shl_load" >&5

+echo "${ECHO_T}$ac_cv_func_shl_load" >&6

+if test $ac_cv_func_shl_load = yes; then

+  lt_cv_dlopen="shl_load"

+else

+  echo "$as_me:$LINENO: checking for shl_load in -ldld" >&5

+echo $ECHO_N "checking for shl_load in -ldld... $ECHO_C" >&6

+if test "${ac_cv_lib_dld_shl_load+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  ac_check_lib_save_LIBS=$LIBS

+LIBS="-ldld  $LIBS"

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+/* Override any gcc2 internal prototype to avoid an error.  */

+#ifdef __cplusplus

+extern "C"

+#endif

+/* We use char because int might match the return type of a gcc2

+   builtin and then its argument prototype would still apply.  */

+char shl_load ();

+int

+main ()

+{

+shl_load ();

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_cv_lib_dld_shl_load=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_cv_lib_dld_shl_load=no

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+LIBS=$ac_check_lib_save_LIBS

+fi

+echo "$as_me:$LINENO: result: $ac_cv_lib_dld_shl_load" >&5

+echo "${ECHO_T}$ac_cv_lib_dld_shl_load" >&6

+if test $ac_cv_lib_dld_shl_load = yes; then

+  lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld"

+else

+  echo "$as_me:$LINENO: checking for dlopen" >&5

+echo $ECHO_N "checking for dlopen... $ECHO_C" >&6

+if test "${ac_cv_func_dlopen+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+/* Define dlopen to an innocuous variant, in case <limits.h> declares dlopen.

+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */

+#define dlopen innocuous_dlopen

+

+/* System header to define __stub macros and hopefully few prototypes,

+    which can conflict with char dlopen (); below.

+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

+    <limits.h> exists even on freestanding compilers.  */

+

+#ifdef __STDC__

+# include <limits.h>

+#else

+# include <assert.h>

+#endif

+

+#undef dlopen

+

+/* Override any gcc2 internal prototype to avoid an error.  */

+#ifdef __cplusplus

+extern "C"

+{

+#endif

+/* We use char because int might match the return type of a gcc2

+   builtin and then its argument prototype would still apply.  */

+char dlopen ();

+/* The GNU C library defines this for functions which it implements

+    to always fail with ENOSYS.  Some functions are actually named

+    something starting with __ and the normal name is an alias.  */

+#if defined (__stub_dlopen) || defined (__stub___dlopen)

+choke me

+#else

+char (*f) () = dlopen;

+#endif

+#ifdef __cplusplus

+}

+#endif

+

+int

+main ()

+{

+return f != dlopen;

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_cv_func_dlopen=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_cv_func_dlopen=no

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+fi

+echo "$as_me:$LINENO: result: $ac_cv_func_dlopen" >&5

+echo "${ECHO_T}$ac_cv_func_dlopen" >&6

+if test $ac_cv_func_dlopen = yes; then

+  lt_cv_dlopen="dlopen"

+else

+  echo "$as_me:$LINENO: checking for dlopen in -ldl" >&5

+echo $ECHO_N "checking for dlopen in -ldl... $ECHO_C" >&6

+if test "${ac_cv_lib_dl_dlopen+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  ac_check_lib_save_LIBS=$LIBS

+LIBS="-ldl  $LIBS"

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+/* Override any gcc2 internal prototype to avoid an error.  */

+#ifdef __cplusplus

+extern "C"

+#endif

+/* We use char because int might match the return type of a gcc2

+   builtin and then its argument prototype would still apply.  */

+char dlopen ();

+int

+main ()

+{

+dlopen ();

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_cv_lib_dl_dlopen=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_cv_lib_dl_dlopen=no

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+LIBS=$ac_check_lib_save_LIBS

+fi

+echo "$as_me:$LINENO: result: $ac_cv_lib_dl_dlopen" >&5

+echo "${ECHO_T}$ac_cv_lib_dl_dlopen" >&6

+if test $ac_cv_lib_dl_dlopen = yes; then

+  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"

+else

+  echo "$as_me:$LINENO: checking for dlopen in -lsvld" >&5

+echo $ECHO_N "checking for dlopen in -lsvld... $ECHO_C" >&6

+if test "${ac_cv_lib_svld_dlopen+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  ac_check_lib_save_LIBS=$LIBS

+LIBS="-lsvld  $LIBS"

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+/* Override any gcc2 internal prototype to avoid an error.  */

+#ifdef __cplusplus

+extern "C"

+#endif

+/* We use char because int might match the return type of a gcc2

+   builtin and then its argument prototype would still apply.  */

+char dlopen ();

+int

+main ()

+{

+dlopen ();

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_cv_lib_svld_dlopen=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_cv_lib_svld_dlopen=no

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+LIBS=$ac_check_lib_save_LIBS

+fi

+echo "$as_me:$LINENO: result: $ac_cv_lib_svld_dlopen" >&5

+echo "${ECHO_T}$ac_cv_lib_svld_dlopen" >&6

+if test $ac_cv_lib_svld_dlopen = yes; then

+  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"

+else

+  echo "$as_me:$LINENO: checking for dld_link in -ldld" >&5

+echo $ECHO_N "checking for dld_link in -ldld... $ECHO_C" >&6

+if test "${ac_cv_lib_dld_dld_link+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  ac_check_lib_save_LIBS=$LIBS

+LIBS="-ldld  $LIBS"

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+/* Override any gcc2 internal prototype to avoid an error.  */

+#ifdef __cplusplus

+extern "C"

+#endif

+/* We use char because int might match the return type of a gcc2

+   builtin and then its argument prototype would still apply.  */

+char dld_link ();

+int

+main ()

+{

+dld_link ();

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_cv_lib_dld_dld_link=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_cv_lib_dld_dld_link=no

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+LIBS=$ac_check_lib_save_LIBS

+fi

+echo "$as_me:$LINENO: result: $ac_cv_lib_dld_dld_link" >&5

+echo "${ECHO_T}$ac_cv_lib_dld_dld_link" >&6

+if test $ac_cv_lib_dld_dld_link = yes; then

+  lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"

+fi

+

+

+fi

+

+

+fi

+

+

+fi

+

+

+fi

+

+

+fi

+

+    ;;

+  esac

+

+  if test "x$lt_cv_dlopen" != xno; then

+    enable_dlopen=yes

+  else

+    enable_dlopen=no

+  fi

+

+  case $lt_cv_dlopen in

+  dlopen)

+    save_CPPFLAGS="$CPPFLAGS"

+    test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"

+

+    save_LDFLAGS="$LDFLAGS"

+    wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"

+

+    save_LIBS="$LIBS"

+    LIBS="$lt_cv_dlopen_libs $LIBS"

+

+    echo "$as_me:$LINENO: checking whether a program can dlopen itself" >&5

+echo $ECHO_N "checking whether a program can dlopen itself... $ECHO_C" >&6

+if test "${lt_cv_dlopen_self+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  	  if test "$cross_compiling" = yes; then :

+  lt_cv_dlopen_self=cross

+else

+  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2

+  lt_status=$lt_dlunknown

+  cat > conftest.$ac_ext <<EOF

+#line 9065 "configure"

+#include "confdefs.h"

+

+#if HAVE_DLFCN_H

+#include <dlfcn.h>

+#endif

+

+#include <stdio.h>

+

+#ifdef RTLD_GLOBAL

+#  define LT_DLGLOBAL		RTLD_GLOBAL

+#else

+#  ifdef DL_GLOBAL

+#    define LT_DLGLOBAL		DL_GLOBAL

+#  else

+#    define LT_DLGLOBAL		0

+#  endif

+#endif

+

+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we

+   find out it does not work in some platform. */

+#ifndef LT_DLLAZY_OR_NOW

+#  ifdef RTLD_LAZY

+#    define LT_DLLAZY_OR_NOW		RTLD_LAZY

+#  else

+#    ifdef DL_LAZY

+#      define LT_DLLAZY_OR_NOW		DL_LAZY

+#    else

+#      ifdef RTLD_NOW

+#        define LT_DLLAZY_OR_NOW	RTLD_NOW

+#      else

+#        ifdef DL_NOW

+#          define LT_DLLAZY_OR_NOW	DL_NOW

+#        else

+#          define LT_DLLAZY_OR_NOW	0

+#        endif

+#      endif

+#    endif

+#  endif

+#endif

+

+#ifdef __cplusplus

+extern "C" void exit (int);

+#endif

+

+void fnord() { int i=42;}

+int main ()

+{

+  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);

+  int status = $lt_dlunknown;

+

+  if (self)

+    {

+      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;

+      else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;

+      /* dlclose (self); */

+    }

+  else

+    puts (dlerror ());

+

+    exit (status);

+}

+EOF

+  if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } && test -s conftest${ac_exeext} 2>/dev/null; then

+    (./conftest; exit; ) >&5 2>/dev/null

+    lt_status=$?

+    case x$lt_status in

+      x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;;

+      x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;;

+      x$lt_dlunknown|x*) lt_cv_dlopen_self=no ;;

+    esac

+  else :

+    # compilation failed

+    lt_cv_dlopen_self=no

+  fi

+fi

+rm -fr conftest*

+

+

+fi

+echo "$as_me:$LINENO: result: $lt_cv_dlopen_self" >&5

+echo "${ECHO_T}$lt_cv_dlopen_self" >&6

+

+    if test "x$lt_cv_dlopen_self" = xyes; then

+      wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"

+      echo "$as_me:$LINENO: checking whether a statically linked program can dlopen itself" >&5

+echo $ECHO_N "checking whether a statically linked program can dlopen itself... $ECHO_C" >&6

+if test "${lt_cv_dlopen_self_static+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  	  if test "$cross_compiling" = yes; then :

+  lt_cv_dlopen_self_static=cross

+else

+  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2

+  lt_status=$lt_dlunknown

+  cat > conftest.$ac_ext <<EOF

+#line 9165 "configure"

+#include "confdefs.h"

+

+#if HAVE_DLFCN_H

+#include <dlfcn.h>

+#endif

+

+#include <stdio.h>

+

+#ifdef RTLD_GLOBAL

+#  define LT_DLGLOBAL		RTLD_GLOBAL

+#else

+#  ifdef DL_GLOBAL

+#    define LT_DLGLOBAL		DL_GLOBAL

+#  else

+#    define LT_DLGLOBAL		0

+#  endif

+#endif

+

+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we

+   find out it does not work in some platform. */

+#ifndef LT_DLLAZY_OR_NOW

+#  ifdef RTLD_LAZY

+#    define LT_DLLAZY_OR_NOW		RTLD_LAZY

+#  else

+#    ifdef DL_LAZY

+#      define LT_DLLAZY_OR_NOW		DL_LAZY

+#    else

+#      ifdef RTLD_NOW

+#        define LT_DLLAZY_OR_NOW	RTLD_NOW

+#      else

+#        ifdef DL_NOW

+#          define LT_DLLAZY_OR_NOW	DL_NOW

+#        else

+#          define LT_DLLAZY_OR_NOW	0

+#        endif

+#      endif

+#    endif

+#  endif

+#endif

+

+#ifdef __cplusplus

+extern "C" void exit (int);

+#endif

+

+void fnord() { int i=42;}

+int main ()

+{

+  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);

+  int status = $lt_dlunknown;

+

+  if (self)

+    {

+      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;

+      else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;

+      /* dlclose (self); */

+    }

+  else

+    puts (dlerror ());

+

+    exit (status);

+}

+EOF

+  if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } && test -s conftest${ac_exeext} 2>/dev/null; then

+    (./conftest; exit; ) >&5 2>/dev/null

+    lt_status=$?

+    case x$lt_status in

+      x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;;

+      x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;;

+      x$lt_dlunknown|x*) lt_cv_dlopen_self_static=no ;;

+    esac

+  else :

+    # compilation failed

+    lt_cv_dlopen_self_static=no

+  fi

+fi

+rm -fr conftest*

+

+

+fi

+echo "$as_me:$LINENO: result: $lt_cv_dlopen_self_static" >&5

+echo "${ECHO_T}$lt_cv_dlopen_self_static" >&6

+    fi

+

+    CPPFLAGS="$save_CPPFLAGS"

+    LDFLAGS="$save_LDFLAGS"

+    LIBS="$save_LIBS"

+    ;;

+  esac

+

+  case $lt_cv_dlopen_self in

+  yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;

+  *) enable_dlopen_self=unknown ;;

+  esac

+

+  case $lt_cv_dlopen_self_static in

+  yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;

+  *) enable_dlopen_self_static=unknown ;;

+  esac

+fi

+

+

+# Report which library types will actually be built

+echo "$as_me:$LINENO: checking if libtool supports shared libraries" >&5

+echo $ECHO_N "checking if libtool supports shared libraries... $ECHO_C" >&6

+echo "$as_me:$LINENO: result: $can_build_shared" >&5

+echo "${ECHO_T}$can_build_shared" >&6

+

+echo "$as_me:$LINENO: checking whether to build shared libraries" >&5

+echo $ECHO_N "checking whether to build shared libraries... $ECHO_C" >&6

+test "$can_build_shared" = "no" && enable_shared=no

+

+# On AIX, shared libraries and static libraries use the same namespace, and

+# are all built from PIC.

+case $host_os in

+aix3*)

+  test "$enable_shared" = yes && enable_static=no

+  if test -n "$RANLIB"; then

+    archive_cmds="$archive_cmds~\$RANLIB \$lib"

+    postinstall_cmds='$RANLIB $lib'

+  fi

+  ;;

+

+aix4* | aix5*)

+  if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then

+    test "$enable_shared" = yes && enable_static=no

+  fi

+    ;;

+esac

+echo "$as_me:$LINENO: result: $enable_shared" >&5

+echo "${ECHO_T}$enable_shared" >&6

+

+echo "$as_me:$LINENO: checking whether to build static libraries" >&5

+echo $ECHO_N "checking whether to build static libraries... $ECHO_C" >&6

+# Make sure either enable_shared or enable_static is yes.

+test "$enable_shared" = yes || enable_static=yes

+echo "$as_me:$LINENO: result: $enable_static" >&5

+echo "${ECHO_T}$enable_static" >&6

+

+# The else clause should only fire when bootstrapping the

+# libtool distribution, otherwise you forgot to ship ltmain.sh

+# with your package, and you will get complaints that there are

+# no rules to generate ltmain.sh.

+if test -f "$ltmain"; then

+  # See if we are running on zsh, and set the options which allow our commands through

+  # without removal of \ escapes.

+  if test -n "${ZSH_VERSION+set}" ; then

+    setopt NO_GLOB_SUBST

+  fi

+  # Now quote all the things that may contain metacharacters while being

+  # careful not to overquote the AC_SUBSTed values.  We take copies of the

+  # variables and quote the copies for generation of the libtool script.

+  for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC LTCFLAGS NM \

+    SED SHELL STRIP \

+    libname_spec library_names_spec soname_spec extract_expsyms_cmds \

+    old_striplib striplib file_magic_cmd finish_cmds finish_eval \

+    deplibs_check_method reload_flag reload_cmds need_locks \

+    lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \

+    lt_cv_sys_global_symbol_to_c_name_address \

+    sys_lib_search_path_spec sys_lib_dlsearch_path_spec \

+    old_postinstall_cmds old_postuninstall_cmds \

+    compiler \

+    CC \

+    LD \

+    lt_prog_compiler_wl \

+    lt_prog_compiler_pic \

+    lt_prog_compiler_static \

+    lt_prog_compiler_no_builtin_flag \

+    export_dynamic_flag_spec \

+    thread_safe_flag_spec \

+    whole_archive_flag_spec \

+    enable_shared_with_static_runtimes \

+    old_archive_cmds \

+    old_archive_from_new_cmds \

+    predep_objects \

+    postdep_objects \

+    predeps \

+    postdeps \

+    compiler_lib_search_path \

+    archive_cmds \

+    archive_expsym_cmds \

+    postinstall_cmds \

+    postuninstall_cmds \

+    old_archive_from_expsyms_cmds \

+    allow_undefined_flag \

+    no_undefined_flag \

+    export_symbols_cmds \

+    hardcode_libdir_flag_spec \

+    hardcode_libdir_flag_spec_ld \

+    hardcode_libdir_separator \

+    hardcode_automatic \

+    module_cmds \

+    module_expsym_cmds \

+    lt_cv_prog_compiler_c_o \

+    exclude_expsyms \

+    include_expsyms; do

+

+    case $var in

+    old_archive_cmds | \

+    old_archive_from_new_cmds | \

+    archive_cmds | \

+    archive_expsym_cmds | \

+    module_cmds | \

+    module_expsym_cmds | \

+    old_archive_from_expsyms_cmds | \

+    export_symbols_cmds | \

+    extract_expsyms_cmds | reload_cmds | finish_cmds | \

+    postinstall_cmds | postuninstall_cmds | \

+    old_postinstall_cmds | old_postuninstall_cmds | \

+    sys_lib_search_path_spec | sys_lib_dlsearch_path_spec)

+      # Double-quote double-evaled strings.

+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\""

+      ;;

+    *)

+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\""

+      ;;

+    esac

+  done

+

+  case $lt_echo in

+  *'\$0 --fallback-echo"')

+    lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'`

+    ;;

+  esac

+

+cfgfile="${ofile}T"

+  trap "$rm \"$cfgfile\"; exit 1" 1 2 15

+  $rm -f "$cfgfile"

+  { echo "$as_me:$LINENO: creating $ofile" >&5

+echo "$as_me: creating $ofile" >&6;}

+

+  cat <<__EOF__ >> "$cfgfile"

+#! $SHELL

+

+# `$echo "$cfgfile" | sed 's%^.*/%%'` - Provide generalized library-building support services.

+# Generated automatically by $PROGRAM (GNU $PACKAGE $VERSION$TIMESTAMP)

+# NOTE: Changes made to this file will be lost: look at ltmain.sh.

+#

+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001

+# Free Software Foundation, Inc.

+#

+# This file is part of GNU Libtool:

+# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996

+#

+# This program is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published by

+# the Free Software Foundation; either version 2 of the License, or

+# (at your option) any later version.

+#

+# This program is distributed in the hope that it will be useful, but

+# WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+# General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with this program; if not, write to the Free Software

+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+#

+# As a special exception to the GNU General Public License, if you

+# distribute this file as part of a program that contains a

+# configuration script generated by Autoconf, you may include it under

+# the same distribution terms that you use for the rest of that program.

+

+# A sed program that does not truncate output.

+SED=$lt_SED

+

+# Sed that helps us avoid accidentally triggering echo(1) options like -n.

+Xsed="$SED -e 1s/^X//"

+

+# The HP-UX ksh and POSIX shell print the target directory to stdout

+# if CDPATH is set.

+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

+

+# The names of the tagged configurations supported by this script.

+available_tags=

+

+# ### BEGIN LIBTOOL CONFIG

+

+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:

+

+# Shell to use when invoking shell scripts.

+SHELL=$lt_SHELL

+

+# Whether or not to build shared libraries.

+build_libtool_libs=$enable_shared

+

+# Whether or not to build static libraries.

+build_old_libs=$enable_static

+

+# Whether or not to add -lc for building shared libraries.

+build_libtool_need_lc=$archive_cmds_need_lc

+

+# Whether or not to disallow shared libs when runtime libs are static

+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes

+

+# Whether or not to optimize for fast installation.

+fast_install=$enable_fast_install

+

+# The host system.

+host_alias=$host_alias

+host=$host

+host_os=$host_os

+

+# The build system.

+build_alias=$build_alias

+build=$build

+build_os=$build_os

+

+# An echo program that does not interpret backslashes.

+echo=$lt_echo

+

+# The archiver.

+AR=$lt_AR

+AR_FLAGS=$lt_AR_FLAGS

+

+# A C compiler.

+LTCC=$lt_LTCC

+

+# LTCC compiler flags.

+LTCFLAGS=$lt_LTCFLAGS

+

+# A language-specific compiler.

+CC=$lt_compiler

+

+# Is the compiler the GNU C compiler?

+with_gcc=$GCC

+

+# An ERE matcher.

+EGREP=$lt_EGREP

+

+# The linker used to build libraries.

+LD=$lt_LD

+

+# Whether we need hard or soft links.

+LN_S=$lt_LN_S

+

+# A BSD-compatible nm program.

+NM=$lt_NM

+

+# A symbol stripping program

+STRIP=$lt_STRIP

+

+# Used to examine libraries when file_magic_cmd begins "file"

+MAGIC_CMD=$MAGIC_CMD

+

+# Used on cygwin: DLL creation program.

+DLLTOOL="$DLLTOOL"

+

+# Used on cygwin: object dumper.

+OBJDUMP="$OBJDUMP"

+

+# Used on cygwin: assembler.

+AS="$AS"

+

+# The name of the directory that contains temporary libtool files.

+objdir=$objdir

+

+# How to create reloadable object files.

+reload_flag=$lt_reload_flag

+reload_cmds=$lt_reload_cmds

+

+# How to pass a linker flag through the compiler.

+wl=$lt_lt_prog_compiler_wl

+

+# Object file suffix (normally "o").

+objext="$ac_objext"

+

+# Old archive suffix (normally "a").

+libext="$libext"

+

+# Shared library suffix (normally ".so").

+shrext_cmds='$shrext_cmds'

+

+# Executable file suffix (normally "").

+exeext="$exeext"

+

+# Additional compiler flags for building library objects.

+pic_flag=$lt_lt_prog_compiler_pic

+pic_mode=$pic_mode

+

+# What is the maximum length of a command?

+max_cmd_len=$lt_cv_sys_max_cmd_len

+

+# Does compiler simultaneously support -c and -o options?

+compiler_c_o=$lt_lt_cv_prog_compiler_c_o

+

+# Must we lock files when doing compilation?

+need_locks=$lt_need_locks

+

+# Do we need the lib prefix for modules?

+need_lib_prefix=$need_lib_prefix

+

+# Do we need a version for libraries?

+need_version=$need_version

+

+# Whether dlopen is supported.

+dlopen_support=$enable_dlopen

+

+# Whether dlopen of programs is supported.

+dlopen_self=$enable_dlopen_self

+

+# Whether dlopen of statically linked programs is supported.

+dlopen_self_static=$enable_dlopen_self_static

+

+# Compiler flag to prevent dynamic linking.

+link_static_flag=$lt_lt_prog_compiler_static

+

+# Compiler flag to turn off builtin functions.

+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag

+

+# Compiler flag to allow reflexive dlopens.

+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec

+

+# Compiler flag to generate shared objects directly from archives.

+whole_archive_flag_spec=$lt_whole_archive_flag_spec

+

+# Compiler flag to generate thread-safe objects.

+thread_safe_flag_spec=$lt_thread_safe_flag_spec

+

+# Library versioning type.

+version_type=$version_type

+

+# Format of library name prefix.

+libname_spec=$lt_libname_spec

+

+# List of archive names.  First name is the real one, the rest are links.

+# The last name is the one that the linker finds with -lNAME.

+library_names_spec=$lt_library_names_spec

+

+# The coded name of the library, if different from the real name.

+soname_spec=$lt_soname_spec

+

+# Commands used to build and install an old-style archive.

+RANLIB=$lt_RANLIB

+old_archive_cmds=$lt_old_archive_cmds

+old_postinstall_cmds=$lt_old_postinstall_cmds

+old_postuninstall_cmds=$lt_old_postuninstall_cmds

+

+# Create an old-style archive from a shared archive.

+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds

+

+# Create a temporary old-style archive to link instead of a shared archive.

+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds

+

+# Commands used to build and install a shared archive.

+archive_cmds=$lt_archive_cmds

+archive_expsym_cmds=$lt_archive_expsym_cmds

+postinstall_cmds=$lt_postinstall_cmds

+postuninstall_cmds=$lt_postuninstall_cmds

+

+# Commands used to build a loadable module (assumed same as above if empty)

+module_cmds=$lt_module_cmds

+module_expsym_cmds=$lt_module_expsym_cmds

+

+# Commands to strip libraries.

+old_striplib=$lt_old_striplib

+striplib=$lt_striplib

+

+# Dependencies to place before the objects being linked to create a

+# shared library.

+predep_objects=$lt_predep_objects

+

+# Dependencies to place after the objects being linked to create a

+# shared library.

+postdep_objects=$lt_postdep_objects

+

+# Dependencies to place before the objects being linked to create a

+# shared library.

+predeps=$lt_predeps

+

+# Dependencies to place after the objects being linked to create a

+# shared library.

+postdeps=$lt_postdeps

+

+# The library search path used internally by the compiler when linking

+# a shared library.

+compiler_lib_search_path=$lt_compiler_lib_search_path

+

+# Method to check whether dependent libraries are shared objects.

+deplibs_check_method=$lt_deplibs_check_method

+

+# Command to use when deplibs_check_method == file_magic.

+file_magic_cmd=$lt_file_magic_cmd

+

+# Flag that allows shared libraries with undefined symbols to be built.

+allow_undefined_flag=$lt_allow_undefined_flag

+

+# Flag that forces no undefined symbols.

+no_undefined_flag=$lt_no_undefined_flag

+

+# Commands used to finish a libtool library installation in a directory.

+finish_cmds=$lt_finish_cmds

+

+# Same as above, but a single script fragment to be evaled but not shown.

+finish_eval=$lt_finish_eval

+

+# Take the output of nm and produce a listing of raw symbols and C names.

+global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe

+

+# Transform the output of nm in a proper C declaration

+global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl

+

+# Transform the output of nm in a C name address pair

+global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address

+

+# This is the shared library runtime path variable.

+runpath_var=$runpath_var

+

+# This is the shared library path variable.

+shlibpath_var=$shlibpath_var

+

+# Is shlibpath searched before the hard-coded library search path?

+shlibpath_overrides_runpath=$shlibpath_overrides_runpath

+

+# How to hardcode a shared library path into an executable.

+hardcode_action=$hardcode_action

+

+# Whether we should hardcode library paths into libraries.

+hardcode_into_libs=$hardcode_into_libs

+

+# Flag to hardcode \$libdir into a binary during linking.

+# This must work even if \$libdir does not exist.

+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec

+

+# If ld is used when linking, flag to hardcode \$libdir into

+# a binary during linking. This must work even if \$libdir does

+# not exist.

+hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld

+

+# Whether we need a single -rpath flag with a separated argument.

+hardcode_libdir_separator=$lt_hardcode_libdir_separator

+

+# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the

+# resulting binary.

+hardcode_direct=$hardcode_direct

+

+# Set to yes if using the -LDIR flag during linking hardcodes DIR into the

+# resulting binary.

+hardcode_minus_L=$hardcode_minus_L

+

+# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into

+# the resulting binary.

+hardcode_shlibpath_var=$hardcode_shlibpath_var

+

+# Set to yes if building a shared library automatically hardcodes DIR into the library

+# and all subsequent libraries and executables linked against it.

+hardcode_automatic=$hardcode_automatic

+

+# Variables whose values should be saved in libtool wrapper scripts and

+# restored at relink time.

+variables_saved_for_relink="$variables_saved_for_relink"

+

+# Whether libtool must link a program against all its dependency libraries.

+link_all_deplibs=$link_all_deplibs

+

+# Compile-time system search path for libraries

+sys_lib_search_path_spec=$lt_sys_lib_search_path_spec

+

+# Run-time system search path for libraries

+sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec

+

+# Fix the shell variable \$srcfile for the compiler.

+fix_srcfile_path="$fix_srcfile_path"

+

+# Set to yes if exported symbols are required.

+always_export_symbols=$always_export_symbols

+

+# The commands to list exported symbols.

+export_symbols_cmds=$lt_export_symbols_cmds

+

+# The commands to extract the exported symbol list from a shared archive.

+extract_expsyms_cmds=$lt_extract_expsyms_cmds

+

+# Symbols that should not be listed in the preloaded symbols.

+exclude_expsyms=$lt_exclude_expsyms

+

+# Symbols that must always be exported.

+include_expsyms=$lt_include_expsyms

+

+# ### END LIBTOOL CONFIG

+

+__EOF__

+

+

+  case $host_os in

+  aix3*)

+    cat <<\EOF >> "$cfgfile"

+

+# AIX sometimes has problems with the GCC collect2 program.  For some

+# reason, if we set the COLLECT_NAMES environment variable, the problems

+# vanish in a puff of smoke.

+if test "X${COLLECT_NAMES+set}" != Xset; then

+  COLLECT_NAMES=

+  export COLLECT_NAMES

+fi

+EOF

+    ;;

+  esac

+

+  # We use sed instead of cat because bash on DJGPP gets confused if

+  # if finds mixed CR/LF and LF-only lines.  Since sed operates in

+  # text mode, it properly converts lines to CR/LF.  This bash problem

+  # is reportedly fixed, but why not run on old versions too?

+  sed '$q' "$ltmain" >> "$cfgfile" || (rm -f "$cfgfile"; exit 1)

+

+  mv -f "$cfgfile" "$ofile" || \

+    (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")

+  chmod +x "$ofile"

+

+else

+  # If there is no Makefile yet, we rely on a make rule to execute

+  # `config.status --recheck' to rerun these tests and create the

+  # libtool script then.

+  ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'`

+  if test -f "$ltmain_in"; then

+    test -f Makefile && make "$ltmain"

+  fi

+fi

+

+

+ac_ext=c

+ac_cpp='$CPP $CPPFLAGS'

+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_c_compiler_gnu

+

+CC="$lt_save_CC"

+

+

+# Check whether --with-tags or --without-tags was given.

+if test "${with_tags+set}" = set; then

+  withval="$with_tags"

+  tagnames="$withval"

+fi;

+

+if test -f "$ltmain" && test -n "$tagnames"; then

+  if test ! -f "${ofile}"; then

+    { echo "$as_me:$LINENO: WARNING: output file \`$ofile' does not exist" >&5

+echo "$as_me: WARNING: output file \`$ofile' does not exist" >&2;}

+  fi

+

+  if test -z "$LTCC"; then

+    eval "`$SHELL ${ofile} --config | grep '^LTCC='`"

+    if test -z "$LTCC"; then

+      { echo "$as_me:$LINENO: WARNING: output file \`$ofile' does not look like a libtool script" >&5

+echo "$as_me: WARNING: output file \`$ofile' does not look like a libtool script" >&2;}

+    else

+      { echo "$as_me:$LINENO: WARNING: using \`LTCC=$LTCC', extracted from \`$ofile'" >&5

+echo "$as_me: WARNING: using \`LTCC=$LTCC', extracted from \`$ofile'" >&2;}

+    fi

+  fi

+  if test -z "$LTCFLAGS"; then

+    eval "`$SHELL ${ofile} --config | grep '^LTCFLAGS='`"

+  fi

+

+  # Extract list of available tagged configurations in $ofile.

+  # Note that this assumes the entire list is on one line.

+  available_tags=`grep "^available_tags=" "${ofile}" | $SED -e 's/available_tags=\(.*$\)/\1/' -e 's/\"//g'`

+

+  lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"

+  for tagname in $tagnames; do

+    IFS="$lt_save_ifs"

+    # Check whether tagname contains only valid characters

+    case `$echo "X$tagname" | $Xsed -e 's:[-_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890,/]::g'` in

+    "") ;;

+    *)  { { echo "$as_me:$LINENO: error: invalid tag name: $tagname" >&5

+echo "$as_me: error: invalid tag name: $tagname" >&2;}

+   { (exit 1); exit 1; }; }

+	;;

+    esac

+

+    if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "${ofile}" > /dev/null

+    then

+      { { echo "$as_me:$LINENO: error: tag name \"$tagname\" already exists" >&5

+echo "$as_me: error: tag name \"$tagname\" already exists" >&2;}

+   { (exit 1); exit 1; }; }

+    fi

+

+    # Update the list of available tags.

+    if test -n "$tagname"; then

+      echo appending configuration tag \"$tagname\" to $ofile

+

+      case $tagname in

+      CXX)

+	if test -n "$CXX" && ( test "X$CXX" != "Xno" &&

+	    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||

+	    (test "X$CXX" != "Xg++"))) ; then

+	  ac_ext=cc

+ac_cpp='$CXXCPP $CPPFLAGS'

+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu

+

+

+

+

+archive_cmds_need_lc_CXX=no

+allow_undefined_flag_CXX=

+always_export_symbols_CXX=no

+archive_expsym_cmds_CXX=

+export_dynamic_flag_spec_CXX=

+hardcode_direct_CXX=no

+hardcode_libdir_flag_spec_CXX=

+hardcode_libdir_flag_spec_ld_CXX=

+hardcode_libdir_separator_CXX=

+hardcode_minus_L_CXX=no

+hardcode_shlibpath_var_CXX=unsupported

+hardcode_automatic_CXX=no

+module_cmds_CXX=

+module_expsym_cmds_CXX=

+link_all_deplibs_CXX=unknown

+old_archive_cmds_CXX=$old_archive_cmds

+no_undefined_flag_CXX=

+whole_archive_flag_spec_CXX=

+enable_shared_with_static_runtimes_CXX=no

+

+# Dependencies to place before and after the object being linked:

+predep_objects_CXX=

+postdep_objects_CXX=

+predeps_CXX=

+postdeps_CXX=

+compiler_lib_search_path_CXX=

+

+# Source file extension for C++ test sources.

+ac_ext=cpp

+

+# Object file extension for compiled C++ test sources.

+objext=o

+objext_CXX=$objext

+

+# Code to be used in simple compile tests

+lt_simple_compile_test_code="int some_variable = 0;\n"

+

+# Code to be used in simple link tests

+lt_simple_link_test_code='int main(int, char *[]) { return(0); }\n'

+

+# ltmain only uses $CC for tagged configurations so make sure $CC is set.

+

+# If no C compiler was specified, use CC.

+LTCC=${LTCC-"$CC"}

+

+# If no C compiler flags were specified, use CFLAGS.

+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}

+

+# Allow CC to be a program name with arguments.

+compiler=$CC

+

+

+# save warnings/boilerplate of simple test code

+ac_outfile=conftest.$ac_objext

+printf "$lt_simple_compile_test_code" >conftest.$ac_ext

+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err

+_lt_compiler_boilerplate=`cat conftest.err`

+$rm conftest*

+

+ac_outfile=conftest.$ac_objext

+printf "$lt_simple_link_test_code" >conftest.$ac_ext

+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err

+_lt_linker_boilerplate=`cat conftest.err`

+$rm conftest*

+

+

+# Allow CC to be a program name with arguments.

+lt_save_CC=$CC

+lt_save_LD=$LD

+lt_save_GCC=$GCC

+GCC=$GXX

+lt_save_with_gnu_ld=$with_gnu_ld

+lt_save_path_LD=$lt_cv_path_LD

+if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then

+  lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx

+else

+  $as_unset lt_cv_prog_gnu_ld

+fi

+if test -n "${lt_cv_path_LDCXX+set}"; then

+  lt_cv_path_LD=$lt_cv_path_LDCXX

+else

+  $as_unset lt_cv_path_LD

+fi

+test -z "${LDCXX+set}" || LD=$LDCXX

+CC=${CXX-"c++"}

+compiler=$CC

+compiler_CXX=$CC

+for cc_temp in $compiler""; do

+  case $cc_temp in

+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;

+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;

+    \-*) ;;

+    *) break;;

+  esac

+done

+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`

+

+

+# We don't want -fno-exception wen compiling C++ code, so set the

+# no_builtin_flag separately

+if test "$GXX" = yes; then

+  lt_prog_compiler_no_builtin_flag_CXX=' -fno-builtin'

+else

+  lt_prog_compiler_no_builtin_flag_CXX=

+fi

+

+if test "$GXX" = yes; then

+  # Set up default GNU C++ configuration

+

+

+# Check whether --with-gnu-ld or --without-gnu-ld was given.

+if test "${with_gnu_ld+set}" = set; then

+  withval="$with_gnu_ld"

+  test "$withval" = no || with_gnu_ld=yes

+else

+  with_gnu_ld=no

+fi;

+ac_prog=ld

+if test "$GCC" = yes; then

+  # Check if gcc -print-prog-name=ld gives a path.

+  echo "$as_me:$LINENO: checking for ld used by $CC" >&5

+echo $ECHO_N "checking for ld used by $CC... $ECHO_C" >&6

+  case $host in

+  *-*-mingw*)

+    # gcc leaves a trailing carriage return which upsets mingw

+    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;

+  *)

+    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;

+  esac

+  case $ac_prog in

+    # Accept absolute paths.

+    [\\/]* | ?:[\\/]*)

+      re_direlt='/[^/][^/]*/\.\./'

+      # Canonicalize the pathname of ld

+      ac_prog=`echo $ac_prog| $SED 's%\\\\%/%g'`

+      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do

+	ac_prog=`echo $ac_prog| $SED "s%$re_direlt%/%"`

+      done

+      test -z "$LD" && LD="$ac_prog"

+      ;;

+  "")

+    # If it fails, then pretend we aren't using GCC.

+    ac_prog=ld

+    ;;

+  *)

+    # If it is relative, then search for the first ld in PATH.

+    with_gnu_ld=unknown

+    ;;

+  esac

+elif test "$with_gnu_ld" = yes; then

+  echo "$as_me:$LINENO: checking for GNU ld" >&5

+echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6

+else

+  echo "$as_me:$LINENO: checking for non-GNU ld" >&5

+echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6

+fi

+if test "${lt_cv_path_LD+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -z "$LD"; then

+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

+  for ac_dir in $PATH; do

+    IFS="$lt_save_ifs"

+    test -z "$ac_dir" && ac_dir=.

+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then

+      lt_cv_path_LD="$ac_dir/$ac_prog"

+      # Check to see if the program is GNU ld.  I'd rather use --version,

+      # but apparently some variants of GNU ld only accept -v.

+      # Break only if it was the GNU/non-GNU ld that we prefer.

+      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in

+      *GNU* | *'with BFD'*)

+	test "$with_gnu_ld" != no && break

+	;;

+      *)

+	test "$with_gnu_ld" != yes && break

+	;;

+      esac

+    fi

+  done

+  IFS="$lt_save_ifs"

+else

+  lt_cv_path_LD="$LD" # Let the user override the test with a path.

+fi

+fi

+

+LD="$lt_cv_path_LD"

+if test -n "$LD"; then

+  echo "$as_me:$LINENO: result: $LD" >&5

+echo "${ECHO_T}$LD" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5

+echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}

+   { (exit 1); exit 1; }; }

+echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5

+echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6

+if test "${lt_cv_prog_gnu_ld+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  # I'd rather use --version here, but apparently some GNU lds only accept -v.

+case `$LD -v 2>&1 </dev/null` in

+*GNU* | *'with BFD'*)

+  lt_cv_prog_gnu_ld=yes

+  ;;

+*)

+  lt_cv_prog_gnu_ld=no

+  ;;

+esac

+fi

+echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5

+echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6

+with_gnu_ld=$lt_cv_prog_gnu_ld

+

+

+

+  # Check if GNU C++ uses GNU ld as the underlying linker, since the

+  # archiving commands below assume that GNU ld is being used.

+  if test "$with_gnu_ld" = yes; then

+    archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'

+    archive_expsym_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+

+    hardcode_libdir_flag_spec_CXX='${wl}--rpath ${wl}$libdir'

+    export_dynamic_flag_spec_CXX='${wl}--export-dynamic'

+

+    # If archive_cmds runs LD, not CC, wlarc should be empty

+    # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to

+    #     investigate it a little bit more. (MM)

+    wlarc='${wl}'

+

+    # ancient GNU ld didn't support --whole-archive et. al.

+    if eval "`$CC -print-prog-name=ld` --help 2>&1" | \

+	grep 'no-whole-archive' > /dev/null; then

+      whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'

+    else

+      whole_archive_flag_spec_CXX=

+    fi

+  else

+    with_gnu_ld=no

+    wlarc=

+

+    # A generic and very simple default shared library creation

+    # command for GNU C++ for the case where it uses the native

+    # linker, instead of GNU ld.  If possible, this setting should

+    # overridden to take advantage of the native linker features on

+    # the platform it is being used on.

+    archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'

+  fi

+

+  # Commands to make compiler produce verbose output that lists

+  # what "hidden" libraries, object files and flags are used when

+  # linking a shared library.

+  output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"'

+

+else

+  GXX=no

+  with_gnu_ld=no

+  wlarc=

+fi

+

+# PORTME: fill in a description of your system's C++ link characteristics

+echo "$as_me:$LINENO: checking whether the $compiler linker ($LD) supports shared libraries" >&5

+echo $ECHO_N "checking whether the $compiler linker ($LD) supports shared libraries... $ECHO_C" >&6

+ld_shlibs_CXX=yes

+case $host_os in

+  aix3*)

+    # FIXME: insert proper C++ library support

+    ld_shlibs_CXX=no

+    ;;

+  aix4* | aix5*)

+    if test "$host_cpu" = ia64; then

+      # On IA64, the linker does run time linking by default, so we don't

+      # have to do anything special.

+      aix_use_runtimelinking=no

+      exp_sym_flag='-Bexport'

+      no_entry_flag=""

+    else

+      aix_use_runtimelinking=no

+

+      # Test if we are trying to use run time linking or normal

+      # AIX style linking. If -brtl is somewhere in LDFLAGS, we

+      # need to do runtime linking.

+      case $host_os in aix4.[23]|aix4.[23].*|aix5*)

+	for ld_flag in $LDFLAGS; do

+	  case $ld_flag in

+	  *-brtl*)

+	    aix_use_runtimelinking=yes

+	    break

+	    ;;

+	  esac

+	done

+	;;

+      esac

+

+      exp_sym_flag='-bexport'

+      no_entry_flag='-bnoentry'

+    fi

+

+    # When large executables or shared objects are built, AIX ld can

+    # have problems creating the table of contents.  If linking a library

+    # or program results in "error TOC overflow" add -mminimal-toc to

+    # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not

+    # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.

+

+    archive_cmds_CXX=''

+    hardcode_direct_CXX=yes

+    hardcode_libdir_separator_CXX=':'

+    link_all_deplibs_CXX=yes

+

+    if test "$GXX" = yes; then

+      case $host_os in aix4.[012]|aix4.[012].*)

+      # We only want to do this on AIX 4.2 and lower, the check

+      # below for broken collect2 doesn't work under 4.3+

+	collect2name=`${CC} -print-prog-name=collect2`

+	if test -f "$collect2name" && \

+	   strings "$collect2name" | grep resolve_lib_name >/dev/null

+	then

+	  # We have reworked collect2

+	  hardcode_direct_CXX=yes

+	else

+	  # We have old collect2

+	  hardcode_direct_CXX=unsupported

+	  # It fails to find uninstalled libraries when the uninstalled

+	  # path is not listed in the libpath.  Setting hardcode_minus_L

+	  # to unsupported forces relinking

+	  hardcode_minus_L_CXX=yes

+	  hardcode_libdir_flag_spec_CXX='-L$libdir'

+	  hardcode_libdir_separator_CXX=

+	fi

+	;;

+      esac

+      shared_flag='-shared'

+      if test "$aix_use_runtimelinking" = yes; then

+	shared_flag="$shared_flag "'${wl}-G'

+      fi

+    else

+      # not using gcc

+      if test "$host_cpu" = ia64; then

+	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release

+	# chokes on -Wl,-G. The following line is correct:

+	shared_flag='-G'

+      else

+	if test "$aix_use_runtimelinking" = yes; then

+	  shared_flag='${wl}-G'

+	else

+	  shared_flag='${wl}-bM:SRE'

+	fi

+      fi

+    fi

+

+    # It seems that -bexpall does not export symbols beginning with

+    # underscore (_), so it is better to generate a list of symbols to export.

+    always_export_symbols_CXX=yes

+    if test "$aix_use_runtimelinking" = yes; then

+      # Warning - without using the other runtime loading flags (-brtl),

+      # -berok will link without error, but may produce a broken library.

+      allow_undefined_flag_CXX='-berok'

+      # Determine the default libpath from the value encoded in an empty executable.

+      cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+int

+main ()

+{

+

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_cxx_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+

+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`

+# Check for a 64-bit object if we didn't find anything.

+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`; fi

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi

+

+      hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath"

+

+      archive_expsym_cmds_CXX="\$CC"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"

+     else

+      if test "$host_cpu" = ia64; then

+	hardcode_libdir_flag_spec_CXX='${wl}-R $libdir:/usr/lib:/lib'

+	allow_undefined_flag_CXX="-z nodefs"

+	archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"

+      else

+	# Determine the default libpath from the value encoded in an empty executable.

+	cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+int

+main ()

+{

+

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_cxx_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+

+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`

+# Check for a 64-bit object if we didn't find anything.

+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`; fi

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi

+

+	hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath"

+	# Warning - without using the other run time loading flags,

+	# -berok will link without error, but may produce a broken library.

+	no_undefined_flag_CXX=' ${wl}-bernotok'

+	allow_undefined_flag_CXX=' ${wl}-berok'

+	# Exported symbols can be pulled into shared objects from archives

+	whole_archive_flag_spec_CXX='$convenience'

+	archive_cmds_need_lc_CXX=yes

+	# This is similar to how AIX traditionally builds its shared libraries.

+	archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'

+      fi

+    fi

+    ;;

+

+  beos*)

+    if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+      allow_undefined_flag_CXX=unsupported

+      # Joseph Beckenbach <jrb3@best.com> says some releases of gcc

+      # support --undefined.  This deserves some investigation.  FIXME

+      archive_cmds_CXX='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+    else

+      ld_shlibs_CXX=no

+    fi

+    ;;

+

+  chorus*)

+    case $cc_basename in

+      *)

+	# FIXME: insert proper C++ library support

+	ld_shlibs_CXX=no

+	;;

+    esac

+    ;;

+

+  cygwin* | mingw* | pw32*)

+    # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, CXX) is actually meaningless,

+    # as there is no search path for DLLs.

+    hardcode_libdir_flag_spec_CXX='-L$libdir'

+    allow_undefined_flag_CXX=unsupported

+    always_export_symbols_CXX=no

+    enable_shared_with_static_runtimes_CXX=yes

+

+    if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then

+      archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'

+      # If the export-symbols file already is a .def file (1st line

+      # is EXPORTS), use it as is; otherwise, prepend...

+      archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then

+	cp $export_symbols $output_objdir/$soname.def;

+      else

+	echo EXPORTS > $output_objdir/$soname.def;

+	cat $export_symbols >> $output_objdir/$soname.def;

+      fi~

+      $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'

+    else

+      ld_shlibs_CXX=no

+    fi

+  ;;

+      darwin* | rhapsody*)

+        case $host_os in

+        rhapsody* | darwin1.[012])

+         allow_undefined_flag_CXX='${wl}-undefined ${wl}suppress'

+         ;;

+       *) # Darwin 1.3 on

+         if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then

+           allow_undefined_flag_CXX='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'

+         else

+           case ${MACOSX_DEPLOYMENT_TARGET} in

+             10.[012])

+               allow_undefined_flag_CXX='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'

+               ;;

+             10.*)

+               allow_undefined_flag_CXX='${wl}-undefined ${wl}dynamic_lookup'

+               ;;

+           esac

+         fi

+         ;;

+        esac

+      archive_cmds_need_lc_CXX=no

+      hardcode_direct_CXX=no

+      hardcode_automatic_CXX=yes

+      hardcode_shlibpath_var_CXX=unsupported

+      whole_archive_flag_spec_CXX=''

+      link_all_deplibs_CXX=yes

+

+    if test "$GXX" = yes ; then

+      lt_int_apple_cc_single_mod=no

+      output_verbose_link_cmd='echo'

+      if $CC -dumpspecs 2>&1 | $EGREP 'single_module' >/dev/null ; then

+       lt_int_apple_cc_single_mod=yes

+      fi

+      if test "X$lt_int_apple_cc_single_mod" = Xyes ; then

+       archive_cmds_CXX='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'

+      else

+          archive_cmds_CXX='$CC -r -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring'

+        fi

+        module_cmds_CXX='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'

+        # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds

+          if test "X$lt_int_apple_cc_single_mod" = Xyes ; then

+            archive_expsym_cmds_CXX='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+          else

+            archive_expsym_cmds_CXX='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+          fi

+            module_expsym_cmds_CXX='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+      else

+      case $cc_basename in

+        xlc*)

+         output_verbose_link_cmd='echo'

+          archive_cmds_CXX='$CC -qmkshrobj ${wl}-single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'

+          module_cmds_CXX='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'

+          # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds

+          archive_expsym_cmds_CXX='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj ${wl}-single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+          module_expsym_cmds_CXX='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+          ;;

+       *)

+         ld_shlibs_CXX=no

+          ;;

+      esac

+      fi

+        ;;

+

+  dgux*)

+    case $cc_basename in

+      ec++*)

+	# FIXME: insert proper C++ library support

+	ld_shlibs_CXX=no

+	;;

+      ghcx*)

+	# Green Hills C++ Compiler

+	# FIXME: insert proper C++ library support

+	ld_shlibs_CXX=no

+	;;

+      *)

+	# FIXME: insert proper C++ library support

+	ld_shlibs_CXX=no

+	;;

+    esac

+    ;;

+  freebsd[12]*)

+    # C++ shared libraries reported to be fairly broken before switch to ELF

+    ld_shlibs_CXX=no

+    ;;

+  freebsd-elf*)

+    archive_cmds_need_lc_CXX=no

+    ;;

+  freebsd* | kfreebsd*-gnu | dragonfly*)

+    # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF

+    # conventions

+    ld_shlibs_CXX=yes

+    ;;

+  gnu*)

+    ;;

+  hpux9*)

+    hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir'

+    hardcode_libdir_separator_CXX=:

+    export_dynamic_flag_spec_CXX='${wl}-E'

+    hardcode_direct_CXX=yes

+    hardcode_minus_L_CXX=yes # Not in the search PATH,

+				# but as the default

+				# location of the library.

+

+    case $cc_basename in

+    CC*)

+      # FIXME: insert proper C++ library support

+      ld_shlibs_CXX=no

+      ;;

+    aCC*)

+      archive_cmds_CXX='$rm $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

+      # Commands to make compiler produce verbose output that lists

+      # what "hidden" libraries, object files and flags are used when

+      # linking a shared library.

+      #

+      # There doesn't appear to be a way to prevent this compiler from

+      # explicitly linking system object files so we need to strip them

+      # from the output so that they don't get included in the library

+      # dependencies.

+      output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | grep "[-]L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

+      ;;

+    *)

+      if test "$GXX" = yes; then

+        archive_cmds_CXX='$rm $output_objdir/$soname~$CC -shared -nostdlib -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

+      else

+        # FIXME: insert proper C++ library support

+        ld_shlibs_CXX=no

+      fi

+      ;;

+    esac

+    ;;

+  hpux10*|hpux11*)

+    if test $with_gnu_ld = no; then

+      hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir'

+      hardcode_libdir_separator_CXX=:

+

+      case $host_cpu in

+      hppa*64*|ia64*)

+	hardcode_libdir_flag_spec_ld_CXX='+b $libdir'

+        ;;

+      *)

+	export_dynamic_flag_spec_CXX='${wl}-E'

+        ;;

+      esac

+    fi

+    case $host_cpu in

+    hppa*64*|ia64*)

+      hardcode_direct_CXX=no

+      hardcode_shlibpath_var_CXX=no

+      ;;

+    *)

+      hardcode_direct_CXX=yes

+      hardcode_minus_L_CXX=yes # Not in the search PATH,

+					      # but as the default

+					      # location of the library.

+      ;;

+    esac

+

+    case $cc_basename in

+      CC*)

+	# FIXME: insert proper C++ library support

+	ld_shlibs_CXX=no

+	;;

+      aCC*)

+	case $host_cpu in

+	hppa*64*)

+	  archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

+	  ;;

+	ia64*)

+	  archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

+	  ;;

+	*)

+	  archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

+	  ;;

+	esac

+	# Commands to make compiler produce verbose output that lists

+	# what "hidden" libraries, object files and flags are used when

+	# linking a shared library.

+	#

+	# There doesn't appear to be a way to prevent this compiler from

+	# explicitly linking system object files so we need to strip them

+	# from the output so that they don't get included in the library

+	# dependencies.

+	output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | grep "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

+	;;

+      *)

+	if test "$GXX" = yes; then

+	  if test $with_gnu_ld = no; then

+	    case $host_cpu in

+	    hppa*64*)

+	      archive_cmds_CXX='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

+	      ;;

+	    ia64*)

+	      archive_cmds_CXX='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

+	      ;;

+	    *)

+	      archive_cmds_CXX='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

+	      ;;

+	    esac

+	  fi

+	else

+	  # FIXME: insert proper C++ library support

+	  ld_shlibs_CXX=no

+	fi

+	;;

+    esac

+    ;;

+  interix3*)

+    hardcode_direct_CXX=no

+    hardcode_shlibpath_var_CXX=no

+    hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'

+    export_dynamic_flag_spec_CXX='${wl}-E'

+    # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.

+    # Instead, shared libraries are loaded at an image base (0x10000000 by

+    # default) and relocated if they conflict, which is a slow very memory

+    # consuming and fragmenting process.  To avoid this, we pick a random,

+    # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link

+    # time.  Moving up from 0x10000000 also allows more sbrk(2) space.

+    archive_cmds_CXX='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'

+    archive_expsym_cmds_CXX='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'

+    ;;

+  irix5* | irix6*)

+    case $cc_basename in

+      CC*)

+	# SGI C++

+	archive_cmds_CXX='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+

+	# Archives containing C++ object files must be created using

+	# "CC -ar", where "CC" is the IRIX C++ compiler.  This is

+	# necessary to make sure instantiated templates are included

+	# in the archive.

+	old_archive_cmds_CXX='$CC -ar -WR,-u -o $oldlib $oldobjs'

+	;;

+      *)

+	if test "$GXX" = yes; then

+	  if test "$with_gnu_ld" = no; then

+	    archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+	  else

+	    archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` -o $lib'

+	  fi

+	fi

+	link_all_deplibs_CXX=yes

+	;;

+    esac

+    hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'

+    hardcode_libdir_separator_CXX=:

+    ;;

+  linux*)

+    case $cc_basename in

+      KCC*)

+	# Kuck and Associates, Inc. (KAI) C++ Compiler

+

+	# KCC will only create a shared library if the output file

+	# ends with ".so" (or ".sl" for HP-UX), so rename the library

+	# to its proper name (with version) after linking.

+	archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'

+	archive_expsym_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib'

+	# Commands to make compiler produce verbose output that lists

+	# what "hidden" libraries, object files and flags are used when

+	# linking a shared library.

+	#

+	# There doesn't appear to be a way to prevent this compiler from

+	# explicitly linking system object files so we need to strip them

+	# from the output so that they don't get included in the library

+	# dependencies.

+	output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | grep "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

+

+	hardcode_libdir_flag_spec_CXX='${wl}--rpath,$libdir'

+	export_dynamic_flag_spec_CXX='${wl}--export-dynamic'

+

+	# Archives containing C++ object files must be created using

+	# "CC -Bstatic", where "CC" is the KAI C++ compiler.

+	old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs'

+	;;

+      icpc*)

+	# Intel C++

+	with_gnu_ld=yes

+	# version 8.0 and above of icpc choke on multiply defined symbols

+	# if we add $predep_objects and $postdep_objects, however 7.1 and

+	# earlier do not add the objects themselves.

+	case `$CC -V 2>&1` in

+	*"Version 7."*)

+  	  archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'

+  	  archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+	  ;;

+	*)  # Version 8.0 or newer

+	  tmp_idyn=

+	  case $host_cpu in

+	    ia64*) tmp_idyn=' -i_dynamic';;

+	  esac

+  	  archive_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+	  archive_expsym_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+	  ;;

+	esac

+	archive_cmds_need_lc_CXX=no

+	hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'

+	export_dynamic_flag_spec_CXX='${wl}--export-dynamic'

+	whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive'

+	;;

+      pgCC*)

+        # Portland Group C++ compiler

+	archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'

+  	archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'

+

+	hardcode_libdir_flag_spec_CXX='${wl}--rpath ${wl}$libdir'

+	export_dynamic_flag_spec_CXX='${wl}--export-dynamic'

+	whole_archive_flag_spec_CXX='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'

+        ;;

+      cxx*)

+	# Compaq C++

+	archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'

+	archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname  -o $lib ${wl}-retain-symbols-file $wl$export_symbols'

+

+	runpath_var=LD_RUN_PATH

+	hardcode_libdir_flag_spec_CXX='-rpath $libdir'

+	hardcode_libdir_separator_CXX=:

+

+	# Commands to make compiler produce verbose output that lists

+	# what "hidden" libraries, object files and flags are used when

+	# linking a shared library.

+	#

+	# There doesn't appear to be a way to prevent this compiler from

+	# explicitly linking system object files so we need to strip them

+	# from the output so that they don't get included in the library

+	# dependencies.

+	output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

+	;;

+    esac

+    ;;

+  lynxos*)

+    # FIXME: insert proper C++ library support

+    ld_shlibs_CXX=no

+    ;;

+  m88k*)

+    # FIXME: insert proper C++ library support

+    ld_shlibs_CXX=no

+    ;;

+  mvs*)

+    case $cc_basename in

+      cxx*)

+	# FIXME: insert proper C++ library support

+	ld_shlibs_CXX=no

+	;;

+      *)

+	# FIXME: insert proper C++ library support

+	ld_shlibs_CXX=no

+	;;

+    esac

+    ;;

+  netbsd* | netbsdelf*-gnu | knetbsd*-gnu)

+    if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

+      archive_cmds_CXX='$LD -Bshareable  -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'

+      wlarc=

+      hardcode_libdir_flag_spec_CXX='-R$libdir'

+      hardcode_direct_CXX=yes

+      hardcode_shlibpath_var_CXX=no

+    fi

+    # Workaround some broken pre-1.5 toolchains

+    output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'

+    ;;

+  openbsd2*)

+    # C++ shared libraries are fairly broken

+    ld_shlibs_CXX=no

+    ;;

+  openbsd*)

+    hardcode_direct_CXX=yes

+    hardcode_shlibpath_var_CXX=no

+    archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'

+    hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'

+    if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

+      archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib'

+      export_dynamic_flag_spec_CXX='${wl}-E'

+      whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'

+    fi

+    output_verbose_link_cmd='echo'

+    ;;

+  osf3*)

+    case $cc_basename in

+      KCC*)

+	# Kuck and Associates, Inc. (KAI) C++ Compiler

+

+	# KCC will only create a shared library if the output file

+	# ends with ".so" (or ".sl" for HP-UX), so rename the library

+	# to its proper name (with version) after linking.

+	archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'

+

+	hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'

+	hardcode_libdir_separator_CXX=:

+

+	# Archives containing C++ object files must be created using

+	# "CC -Bstatic", where "CC" is the KAI C++ compiler.

+	old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs'

+

+	;;

+      RCC*)

+	# Rational C++ 2.4.1

+	# FIXME: insert proper C++ library support

+	ld_shlibs_CXX=no

+	;;

+      cxx*)

+	allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*'

+	archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && echo ${wl}-set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+

+	hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'

+	hardcode_libdir_separator_CXX=:

+

+	# Commands to make compiler produce verbose output that lists

+	# what "hidden" libraries, object files and flags are used when

+	# linking a shared library.

+	#

+	# There doesn't appear to be a way to prevent this compiler from

+	# explicitly linking system object files so we need to strip them

+	# from the output so that they don't get included in the library

+	# dependencies.

+	output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld" | grep -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

+	;;

+      *)

+	if test "$GXX" = yes && test "$with_gnu_ld" = no; then

+	  allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*'

+	  archive_cmds_CXX='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+

+	  hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'

+	  hardcode_libdir_separator_CXX=:

+

+	  # Commands to make compiler produce verbose output that lists

+	  # what "hidden" libraries, object files and flags are used when

+	  # linking a shared library.

+	  output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"'

+

+	else

+	  # FIXME: insert proper C++ library support

+	  ld_shlibs_CXX=no

+	fi

+	;;

+    esac

+    ;;

+  osf4* | osf5*)

+    case $cc_basename in

+      KCC*)

+	# Kuck and Associates, Inc. (KAI) C++ Compiler

+

+	# KCC will only create a shared library if the output file

+	# ends with ".so" (or ".sl" for HP-UX), so rename the library

+	# to its proper name (with version) after linking.

+	archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'

+

+	hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'

+	hardcode_libdir_separator_CXX=:

+

+	# Archives containing C++ object files must be created using

+	# the KAI C++ compiler.

+	old_archive_cmds_CXX='$CC -o $oldlib $oldobjs'

+	;;

+      RCC*)

+	# Rational C++ 2.4.1

+	# FIXME: insert proper C++ library support

+	ld_shlibs_CXX=no

+	;;

+      cxx*)

+	allow_undefined_flag_CXX=' -expect_unresolved \*'

+	archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+	archive_expsym_cmds_CXX='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~

+	  echo "-hidden">> $lib.exp~

+	  $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname -Wl,-input -Wl,$lib.exp  `test -n "$verstring" && echo -set_version	$verstring` -update_registry ${output_objdir}/so_locations -o $lib~

+	  $rm $lib.exp'

+

+	hardcode_libdir_flag_spec_CXX='-rpath $libdir'

+	hardcode_libdir_separator_CXX=:

+

+	# Commands to make compiler produce verbose output that lists

+	# what "hidden" libraries, object files and flags are used when

+	# linking a shared library.

+	#

+	# There doesn't appear to be a way to prevent this compiler from

+	# explicitly linking system object files so we need to strip them

+	# from the output so that they don't get included in the library

+	# dependencies.

+	output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld" | grep -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

+	;;

+      *)

+	if test "$GXX" = yes && test "$with_gnu_ld" = no; then

+	  allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*'

+	 archive_cmds_CXX='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+

+	  hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'

+	  hardcode_libdir_separator_CXX=:

+

+	  # Commands to make compiler produce verbose output that lists

+	  # what "hidden" libraries, object files and flags are used when

+	  # linking a shared library.

+	  output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"'

+

+	else

+	  # FIXME: insert proper C++ library support

+	  ld_shlibs_CXX=no

+	fi

+	;;

+    esac

+    ;;

+  psos*)

+    # FIXME: insert proper C++ library support

+    ld_shlibs_CXX=no

+    ;;

+  sunos4*)

+    case $cc_basename in

+      CC*)

+	# Sun C++ 4.x

+	# FIXME: insert proper C++ library support

+	ld_shlibs_CXX=no

+	;;

+      lcc*)

+	# Lucid

+	# FIXME: insert proper C++ library support

+	ld_shlibs_CXX=no

+	;;

+      *)

+	# FIXME: insert proper C++ library support

+	ld_shlibs_CXX=no

+	;;

+    esac

+    ;;

+  solaris*)

+    case $cc_basename in

+      CC*)

+	# Sun C++ 4.2, 5.x and Centerline C++

+        archive_cmds_need_lc_CXX=yes

+	no_undefined_flag_CXX=' -zdefs'

+	archive_cmds_CXX='$CC -G${allow_undefined_flag}  -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

+	archive_expsym_cmds_CXX='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

+	$CC -G${allow_undefined_flag}  ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'

+

+	hardcode_libdir_flag_spec_CXX='-R$libdir'

+	hardcode_shlibpath_var_CXX=no

+	case $host_os in

+	  solaris2.[0-5] | solaris2.[0-5].*) ;;

+	  *)

+	    # The C++ compiler is used as linker so we must use $wl

+	    # flag to pass the commands to the underlying system

+	    # linker. We must also pass each convience library through

+	    # to the system linker between allextract/defaultextract.

+	    # The C++ compiler will combine linker options so we

+	    # cannot just pass the convience library names through

+	    # without $wl.

+	    # Supported since Solaris 2.6 (maybe 2.5.1?)

+	    whole_archive_flag_spec_CXX='${wl}-z ${wl}allextract`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}-z ${wl}defaultextract'

+	    ;;

+	esac

+	link_all_deplibs_CXX=yes

+

+	output_verbose_link_cmd='echo'

+

+	# Archives containing C++ object files must be created using

+	# "CC -xar", where "CC" is the Sun C++ compiler.  This is

+	# necessary to make sure instantiated templates are included

+	# in the archive.

+	old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs'

+	;;

+      gcx*)

+	# Green Hills C++ Compiler

+	archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'

+

+	# The C++ compiler must be used to create the archive.

+	old_archive_cmds_CXX='$CC $LDFLAGS -archive -o $oldlib $oldobjs'

+	;;

+      *)

+	# GNU C++ compiler with Solaris linker

+	if test "$GXX" = yes && test "$with_gnu_ld" = no; then

+	  no_undefined_flag_CXX=' ${wl}-z ${wl}defs'

+	  if $CC --version | grep -v '^2\.7' > /dev/null; then

+	    archive_cmds_CXX='$CC -shared -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'

+	    archive_expsym_cmds_CXX='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

+		$CC -shared -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'

+

+	    # Commands to make compiler produce verbose output that lists

+	    # what "hidden" libraries, object files and flags are used when

+	    # linking a shared library.

+	    output_verbose_link_cmd="$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep \"\-L\""

+	  else

+	    # g++ 2.7 appears to require `-G' NOT `-shared' on this

+	    # platform.

+	    archive_cmds_CXX='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'

+	    archive_expsym_cmds_CXX='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

+		$CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'

+

+	    # Commands to make compiler produce verbose output that lists

+	    # what "hidden" libraries, object files and flags are used when

+	    # linking a shared library.

+	    output_verbose_link_cmd="$CC -G $CFLAGS -v conftest.$objext 2>&1 | grep \"\-L\""

+	  fi

+

+	  hardcode_libdir_flag_spec_CXX='${wl}-R $wl$libdir'

+	fi

+	;;

+    esac

+    ;;

+  sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)

+    no_undefined_flag_CXX='${wl}-z,text'

+    archive_cmds_need_lc_CXX=no

+    hardcode_shlibpath_var_CXX=no

+    runpath_var='LD_RUN_PATH'

+

+    case $cc_basename in

+      CC*)

+	archive_cmds_CXX='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+	;;

+      *)

+	archive_cmds_CXX='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+	;;

+    esac

+    ;;

+  sysv5* | sco3.2v5* | sco5v6*)

+    # Note: We can NOT use -z defs as we might desire, because we do not

+    # link with -lc, and that would cause any symbols used from libc to

+    # always be unresolved, which means just about no library would

+    # ever link correctly.  If we're not using GNU ld we use -z text

+    # though, which does catch some bad symbols but isn't as heavy-handed

+    # as -z defs.

+    # For security reasons, it is highly recommended that you always

+    # use absolute paths for naming shared libraries, and exclude the

+    # DT_RUNPATH tag from executables and libraries.  But doing so

+    # requires that you compile everything twice, which is a pain.

+    # So that behaviour is only enabled if SCOABSPATH is set to a

+    # non-empty value in the environment.  Most likely only useful for

+    # creating official distributions of packages.

+    # This is a hack until libtool officially supports absolute path

+    # names for shared libraries.

+    no_undefined_flag_CXX='${wl}-z,text'

+    allow_undefined_flag_CXX='${wl}-z,nodefs'

+    archive_cmds_need_lc_CXX=no

+    hardcode_shlibpath_var_CXX=no

+    hardcode_libdir_flag_spec_CXX='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'

+    hardcode_libdir_separator_CXX=':'

+    link_all_deplibs_CXX=yes

+    export_dynamic_flag_spec_CXX='${wl}-Bexport'

+    runpath_var='LD_RUN_PATH'

+

+    case $cc_basename in

+      CC*)

+	archive_cmds_CXX='$CC -G ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	;;

+      *)

+	archive_cmds_CXX='$CC -shared ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	;;

+    esac

+    ;;

+  tandem*)

+    case $cc_basename in

+      NCC*)

+	# NonStop-UX NCC 3.20

+	# FIXME: insert proper C++ library support

+	ld_shlibs_CXX=no

+	;;

+      *)

+	# FIXME: insert proper C++ library support

+	ld_shlibs_CXX=no

+	;;

+    esac

+    ;;

+  vxworks*)

+    # FIXME: insert proper C++ library support

+    ld_shlibs_CXX=no

+    ;;

+  *)

+    # FIXME: insert proper C++ library support

+    ld_shlibs_CXX=no

+    ;;

+esac

+echo "$as_me:$LINENO: result: $ld_shlibs_CXX" >&5

+echo "${ECHO_T}$ld_shlibs_CXX" >&6

+test "$ld_shlibs_CXX" = no && can_build_shared=no

+

+GCC_CXX="$GXX"

+LD_CXX="$LD"

+

+

+cat > conftest.$ac_ext <<EOF

+class Foo

+{

+public:

+  Foo (void) { a = 0; }

+private:

+  int a;

+};

+EOF

+

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; then

+  # Parse the compiler output and extract the necessary

+  # objects, libraries and library flags.

+

+  # Sentinel used to keep track of whether or not we are before

+  # the conftest object file.

+  pre_test_object_deps_done=no

+

+  # The `*' in the case matches for architectures that use `case' in

+  # $output_verbose_cmd can trigger glob expansion during the loop

+  # eval without this substitution.

+  output_verbose_link_cmd=`$echo "X$output_verbose_link_cmd" | $Xsed -e "$no_glob_subst"`

+

+  for p in `eval $output_verbose_link_cmd`; do

+    case $p in

+

+    -L* | -R* | -l*)

+       # Some compilers place space between "-{L,R}" and the path.

+       # Remove the space.

+       if test $p = "-L" \

+	  || test $p = "-R"; then

+	 prev=$p

+	 continue

+       else

+	 prev=

+       fi

+

+       if test "$pre_test_object_deps_done" = no; then

+	 case $p in

+	 -L* | -R*)

+	   # Internal compiler library paths should come after those

+	   # provided the user.  The postdeps already come after the

+	   # user supplied libs so there is no need to process them.

+	   if test -z "$compiler_lib_search_path_CXX"; then

+	     compiler_lib_search_path_CXX="${prev}${p}"

+	   else

+	     compiler_lib_search_path_CXX="${compiler_lib_search_path_CXX} ${prev}${p}"

+	   fi

+	   ;;

+	 # The "-l" case would never come before the object being

+	 # linked, so don't bother handling this case.

+	 esac

+       else

+	 if test -z "$postdeps_CXX"; then

+	   postdeps_CXX="${prev}${p}"

+	 else

+	   postdeps_CXX="${postdeps_CXX} ${prev}${p}"

+	 fi

+       fi

+       ;;

+

+    *.$objext)

+       # This assumes that the test object file only shows up

+       # once in the compiler output.

+       if test "$p" = "conftest.$objext"; then

+	 pre_test_object_deps_done=yes

+	 continue

+       fi

+

+       if test "$pre_test_object_deps_done" = no; then

+	 if test -z "$predep_objects_CXX"; then

+	   predep_objects_CXX="$p"

+	 else

+	   predep_objects_CXX="$predep_objects_CXX $p"

+	 fi

+       else

+	 if test -z "$postdep_objects_CXX"; then

+	   postdep_objects_CXX="$p"

+	 else

+	   postdep_objects_CXX="$postdep_objects_CXX $p"

+	 fi

+       fi

+       ;;

+

+    *) ;; # Ignore the rest.

+

+    esac

+  done

+

+  # Clean up.

+  rm -f a.out a.exe

+else

+  echo "libtool.m4: error: problem compiling CXX test program"

+fi

+

+$rm -f confest.$objext

+

+# PORTME: override above test on systems where it is broken

+case $host_os in

+interix3*)

+  # Interix 3.5 installs completely hosed .la files for C++, so rather than

+  # hack all around it, let's just trust "g++" to DTRT.

+  predep_objects_CXX=

+  postdep_objects_CXX=

+  postdeps_CXX=

+  ;;

+

+solaris*)

+  case $cc_basename in

+  CC*)

+    # Adding this requires a known-good setup of shared libraries for

+    # Sun compiler versions before 5.6, else PIC objects from an old

+    # archive will be linked into the output, leading to subtle bugs.

+    postdeps_CXX='-lCstd -lCrun'

+    ;;

+  esac

+  ;;

+esac

+

+

+case " $postdeps_CXX " in

+*" -lc "*) archive_cmds_need_lc_CXX=no ;;

+esac

+

+lt_prog_compiler_wl_CXX=

+lt_prog_compiler_pic_CXX=

+lt_prog_compiler_static_CXX=

+

+echo "$as_me:$LINENO: checking for $compiler option to produce PIC" >&5

+echo $ECHO_N "checking for $compiler option to produce PIC... $ECHO_C" >&6

+

+  # C++ specific cases for pic, static, wl, etc.

+  if test "$GXX" = yes; then

+    lt_prog_compiler_wl_CXX='-Wl,'

+    lt_prog_compiler_static_CXX='-static'

+

+    case $host_os in

+    aix*)

+      # All AIX code is PIC.

+      if test "$host_cpu" = ia64; then

+	# AIX 5 now supports IA64 processor

+	lt_prog_compiler_static_CXX='-Bstatic'

+      fi

+      ;;

+    amigaos*)

+      # FIXME: we need at least 68020 code to build shared libraries, but

+      # adding the `-m68020' flag to GCC prevents building anything better,

+      # like `-m68040'.

+      lt_prog_compiler_pic_CXX='-m68020 -resident32 -malways-restore-a4'

+      ;;

+    beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)

+      # PIC is the default for these OSes.

+      ;;

+    mingw* | os2* | pw32*)

+      # This hack is so that the source file can tell whether it is being

+      # built for inclusion in a dll (and should export symbols for example).

+      lt_prog_compiler_pic_CXX='-DDLL_EXPORT'

+      ;;

+    darwin* | rhapsody*)

+      # PIC is the default on this platform

+      # Common symbols not allowed in MH_DYLIB files

+      lt_prog_compiler_pic_CXX='-fno-common'

+      ;;

+    *djgpp*)

+      # DJGPP does not support shared libraries at all

+      lt_prog_compiler_pic_CXX=

+      ;;

+    interix3*)

+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.

+      # Instead, we relocate shared libraries at runtime.

+      ;;

+    sysv4*MP*)

+      if test -d /usr/nec; then

+	lt_prog_compiler_pic_CXX=-Kconform_pic

+      fi

+      ;;

+    hpux*)

+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but

+      # not for PA HP-UX.

+      case $host_cpu in

+      hppa*64*|ia64*)

+	;;

+      *)

+	lt_prog_compiler_pic_CXX='-fPIC'

+	;;

+      esac

+      ;;

+    *)

+      lt_prog_compiler_pic_CXX='-fPIC'

+      ;;

+    esac

+  else

+    case $host_os in

+      aix4* | aix5*)

+	# All AIX code is PIC.

+	if test "$host_cpu" = ia64; then

+	  # AIX 5 now supports IA64 processor

+	  lt_prog_compiler_static_CXX='-Bstatic'

+	else

+	  lt_prog_compiler_static_CXX='-bnso -bI:/lib/syscalls.exp'

+	fi

+	;;

+      chorus*)

+	case $cc_basename in

+	cxch68*)

+	  # Green Hills C++ Compiler

+	  # _LT_AC_TAGVAR(lt_prog_compiler_static, CXX)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"

+	  ;;

+	esac

+	;;

+       darwin*)

+         # PIC is the default on this platform

+         # Common symbols not allowed in MH_DYLIB files

+         case $cc_basename in

+           xlc*)

+           lt_prog_compiler_pic_CXX='-qnocommon'

+           lt_prog_compiler_wl_CXX='-Wl,'

+           ;;

+         esac

+       ;;

+      dgux*)

+	case $cc_basename in

+	  ec++*)

+	    lt_prog_compiler_pic_CXX='-KPIC'

+	    ;;

+	  ghcx*)

+	    # Green Hills C++ Compiler

+	    lt_prog_compiler_pic_CXX='-pic'

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      freebsd* | kfreebsd*-gnu | dragonfly*)

+	# FreeBSD uses GNU C++

+	;;

+      hpux9* | hpux10* | hpux11*)

+	case $cc_basename in

+	  CC*)

+	    lt_prog_compiler_wl_CXX='-Wl,'

+	    lt_prog_compiler_static_CXX='${wl}-a ${wl}archive'

+	    if test "$host_cpu" != ia64; then

+	      lt_prog_compiler_pic_CXX='+Z'

+	    fi

+	    ;;

+	  aCC*)

+	    lt_prog_compiler_wl_CXX='-Wl,'

+	    lt_prog_compiler_static_CXX='${wl}-a ${wl}archive'

+	    case $host_cpu in

+	    hppa*64*|ia64*)

+	      # +Z the default

+	      ;;

+	    *)

+	      lt_prog_compiler_pic_CXX='+Z'

+	      ;;

+	    esac

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      interix*)

+	# This is c89, which is MS Visual C++ (no shared libs)

+	# Anyone wants to do a port?

+	;;

+      irix5* | irix6* | nonstopux*)

+	case $cc_basename in

+	  CC*)

+	    lt_prog_compiler_wl_CXX='-Wl,'

+	    lt_prog_compiler_static_CXX='-non_shared'

+	    # CC pic flag -KPIC is the default.

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      linux*)

+	case $cc_basename in

+	  KCC*)

+	    # KAI C++ Compiler

+	    lt_prog_compiler_wl_CXX='--backend -Wl,'

+	    lt_prog_compiler_pic_CXX='-fPIC'

+	    ;;

+	  icpc* | ecpc*)

+	    # Intel C++

+	    lt_prog_compiler_wl_CXX='-Wl,'

+	    lt_prog_compiler_pic_CXX='-KPIC'

+	    lt_prog_compiler_static_CXX='-static'

+	    ;;

+	  pgCC*)

+	    # Portland Group C++ compiler.

+	    lt_prog_compiler_wl_CXX='-Wl,'

+	    lt_prog_compiler_pic_CXX='-fpic'

+	    lt_prog_compiler_static_CXX='-Bstatic'

+	    ;;

+	  cxx*)

+	    # Compaq C++

+	    # Make sure the PIC flag is empty.  It appears that all Alpha

+	    # Linux and Compaq Tru64 Unix objects are PIC.

+	    lt_prog_compiler_pic_CXX=

+	    lt_prog_compiler_static_CXX='-non_shared'

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      lynxos*)

+	;;

+      m88k*)

+	;;

+      mvs*)

+	case $cc_basename in

+	  cxx*)

+	    lt_prog_compiler_pic_CXX='-W c,exportall'

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      netbsd* | netbsdelf*-gnu | knetbsd*-gnu)

+	;;

+      osf3* | osf4* | osf5*)

+	case $cc_basename in

+	  KCC*)

+	    lt_prog_compiler_wl_CXX='--backend -Wl,'

+	    ;;

+	  RCC*)

+	    # Rational C++ 2.4.1

+	    lt_prog_compiler_pic_CXX='-pic'

+	    ;;

+	  cxx*)

+	    # Digital/Compaq C++

+	    lt_prog_compiler_wl_CXX='-Wl,'

+	    # Make sure the PIC flag is empty.  It appears that all Alpha

+	    # Linux and Compaq Tru64 Unix objects are PIC.

+	    lt_prog_compiler_pic_CXX=

+	    lt_prog_compiler_static_CXX='-non_shared'

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      psos*)

+	;;

+      solaris*)

+	case $cc_basename in

+	  CC*)

+	    # Sun C++ 4.2, 5.x and Centerline C++

+	    lt_prog_compiler_pic_CXX='-KPIC'

+	    lt_prog_compiler_static_CXX='-Bstatic'

+	    lt_prog_compiler_wl_CXX='-Qoption ld '

+	    ;;

+	  gcx*)

+	    # Green Hills C++ Compiler

+	    lt_prog_compiler_pic_CXX='-PIC'

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      sunos4*)

+	case $cc_basename in

+	  CC*)

+	    # Sun C++ 4.x

+	    lt_prog_compiler_pic_CXX='-pic'

+	    lt_prog_compiler_static_CXX='-Bstatic'

+	    ;;

+	  lcc*)

+	    # Lucid

+	    lt_prog_compiler_pic_CXX='-pic'

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      tandem*)

+	case $cc_basename in

+	  NCC*)

+	    # NonStop-UX NCC 3.20

+	    lt_prog_compiler_pic_CXX='-KPIC'

+	    ;;

+	  *)

+	    ;;

+	esac

+	;;

+      sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)

+	case $cc_basename in

+	  CC*)

+	    lt_prog_compiler_wl_CXX='-Wl,'

+	    lt_prog_compiler_pic_CXX='-KPIC'

+	    lt_prog_compiler_static_CXX='-Bstatic'

+	    ;;

+	esac

+	;;

+      vxworks*)

+	;;

+      *)

+	lt_prog_compiler_can_build_shared_CXX=no

+	;;

+    esac

+  fi

+

+echo "$as_me:$LINENO: result: $lt_prog_compiler_pic_CXX" >&5

+echo "${ECHO_T}$lt_prog_compiler_pic_CXX" >&6

+

+#

+# Check to make sure the PIC flag actually works.

+#

+if test -n "$lt_prog_compiler_pic_CXX"; then

+

+echo "$as_me:$LINENO: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5

+echo $ECHO_N "checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works... $ECHO_C" >&6

+if test "${lt_prog_compiler_pic_works_CXX+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  lt_prog_compiler_pic_works_CXX=no

+  ac_outfile=conftest.$ac_objext

+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext

+   lt_compiler_flag="$lt_prog_compiler_pic_CXX -DPIC"

+   # Insert the option either (1) after the last *FLAGS variable, or

+   # (2) before a word containing "conftest.", or (3) at the end.

+   # Note that $ac_compile itself does not contain backslashes and begins

+   # with a dollar sign (not a hyphen), so the echo should work correctly.

+   # The option is referenced via a variable to avoid confusing sed.

+   lt_compile=`echo "$ac_compile" | $SED \

+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \

+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \

+   -e 's:$: $lt_compiler_flag:'`

+   (eval echo "\"\$as_me:11503: $lt_compile\"" >&5)

+   (eval "$lt_compile" 2>conftest.err)

+   ac_status=$?

+   cat conftest.err >&5

+   echo "$as_me:11507: \$? = $ac_status" >&5

+   if (exit $ac_status) && test -s "$ac_outfile"; then

+     # The compiler can only warn and ignore the option if not recognized

+     # So say no if there are warnings other than the usual output.

+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp

+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then

+       lt_prog_compiler_pic_works_CXX=yes

+     fi

+   fi

+   $rm conftest*

+

+fi

+echo "$as_me:$LINENO: result: $lt_prog_compiler_pic_works_CXX" >&5

+echo "${ECHO_T}$lt_prog_compiler_pic_works_CXX" >&6

+

+if test x"$lt_prog_compiler_pic_works_CXX" = xyes; then

+    case $lt_prog_compiler_pic_CXX in

+     "" | " "*) ;;

+     *) lt_prog_compiler_pic_CXX=" $lt_prog_compiler_pic_CXX" ;;

+     esac

+else

+    lt_prog_compiler_pic_CXX=

+     lt_prog_compiler_can_build_shared_CXX=no

+fi

+

+fi

+case $host_os in

+  # For platforms which do not support PIC, -DPIC is meaningless:

+  *djgpp*)

+    lt_prog_compiler_pic_CXX=

+    ;;

+  *)

+    lt_prog_compiler_pic_CXX="$lt_prog_compiler_pic_CXX -DPIC"

+    ;;

+esac

+

+#

+# Check to make sure the static flag actually works.

+#

+wl=$lt_prog_compiler_wl_CXX eval lt_tmp_static_flag=\"$lt_prog_compiler_static_CXX\"

+echo "$as_me:$LINENO: checking if $compiler static flag $lt_tmp_static_flag works" >&5

+echo $ECHO_N "checking if $compiler static flag $lt_tmp_static_flag works... $ECHO_C" >&6

+if test "${lt_prog_compiler_static_works_CXX+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  lt_prog_compiler_static_works_CXX=no

+   save_LDFLAGS="$LDFLAGS"

+   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"

+   printf "$lt_simple_link_test_code" > conftest.$ac_ext

+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then

+     # The linker can only warn and ignore the option if not recognized

+     # So say no if there are warnings

+     if test -s conftest.err; then

+       # Append any errors to the config.log.

+       cat conftest.err 1>&5

+       $echo "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp

+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

+       if diff conftest.exp conftest.er2 >/dev/null; then

+         lt_prog_compiler_static_works_CXX=yes

+       fi

+     else

+       lt_prog_compiler_static_works_CXX=yes

+     fi

+   fi

+   $rm conftest*

+   LDFLAGS="$save_LDFLAGS"

+

+fi

+echo "$as_me:$LINENO: result: $lt_prog_compiler_static_works_CXX" >&5

+echo "${ECHO_T}$lt_prog_compiler_static_works_CXX" >&6

+

+if test x"$lt_prog_compiler_static_works_CXX" = xyes; then

+    :

+else

+    lt_prog_compiler_static_CXX=

+fi

+

+

+echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5

+echo $ECHO_N "checking if $compiler supports -c -o file.$ac_objext... $ECHO_C" >&6

+if test "${lt_cv_prog_compiler_c_o_CXX+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  lt_cv_prog_compiler_c_o_CXX=no

+   $rm -r conftest 2>/dev/null

+   mkdir conftest

+   cd conftest

+   mkdir out

+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext

+

+   lt_compiler_flag="-o out/conftest2.$ac_objext"

+   # Insert the option either (1) after the last *FLAGS variable, or

+   # (2) before a word containing "conftest.", or (3) at the end.

+   # Note that $ac_compile itself does not contain backslashes and begins

+   # with a dollar sign (not a hyphen), so the echo should work correctly.

+   lt_compile=`echo "$ac_compile" | $SED \

+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \

+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \

+   -e 's:$: $lt_compiler_flag:'`

+   (eval echo "\"\$as_me:11607: $lt_compile\"" >&5)

+   (eval "$lt_compile" 2>out/conftest.err)

+   ac_status=$?

+   cat out/conftest.err >&5

+   echo "$as_me:11611: \$? = $ac_status" >&5

+   if (exit $ac_status) && test -s out/conftest2.$ac_objext

+   then

+     # The compiler can only warn and ignore the option if not recognized

+     # So say no if there are warnings

+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp

+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2

+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then

+       lt_cv_prog_compiler_c_o_CXX=yes

+     fi

+   fi

+   chmod u+w . 2>&5

+   $rm conftest*

+   # SGI C++ compiler will create directory out/ii_files/ for

+   # template instantiation

+   test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files

+   $rm out/* && rmdir out

+   cd ..

+   rmdir conftest

+   $rm conftest*

+

+fi

+echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_c_o_CXX" >&5

+echo "${ECHO_T}$lt_cv_prog_compiler_c_o_CXX" >&6

+

+

+hard_links="nottested"

+if test "$lt_cv_prog_compiler_c_o_CXX" = no && test "$need_locks" != no; then

+  # do not overwrite the value of need_locks provided by the user

+  echo "$as_me:$LINENO: checking if we can lock with hard links" >&5

+echo $ECHO_N "checking if we can lock with hard links... $ECHO_C" >&6

+  hard_links=yes

+  $rm conftest*

+  ln conftest.a conftest.b 2>/dev/null && hard_links=no

+  touch conftest.a

+  ln conftest.a conftest.b 2>&5 || hard_links=no

+  ln conftest.a conftest.b 2>/dev/null && hard_links=no

+  echo "$as_me:$LINENO: result: $hard_links" >&5

+echo "${ECHO_T}$hard_links" >&6

+  if test "$hard_links" = no; then

+    { echo "$as_me:$LINENO: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5

+echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}

+    need_locks=warn

+  fi

+else

+  need_locks=no

+fi

+

+echo "$as_me:$LINENO: checking whether the $compiler linker ($LD) supports shared libraries" >&5

+echo $ECHO_N "checking whether the $compiler linker ($LD) supports shared libraries... $ECHO_C" >&6

+

+  export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'

+  case $host_os in

+  aix4* | aix5*)

+    # If we're using GNU nm, then we don't want the "-C" option.

+    # -C means demangle to AIX nm, but means don't demangle with GNU nm

+    if $NM -V 2>&1 | grep 'GNU' > /dev/null; then

+      export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols'

+    else

+      export_symbols_cmds_CXX='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols'

+    fi

+    ;;

+  pw32*)

+    export_symbols_cmds_CXX="$ltdll_cmds"

+  ;;

+  cygwin* | mingw*)

+    export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS] /s/.* \([^ ]*\)/\1 DATA/;/^.* __nm__/s/^.* __nm__\([^ ]*\) [^ ]*/\1 DATA/;/^I /d;/^[AITW] /s/.* //'\'' | sort | uniq > $export_symbols'

+  ;;

+  kfreebsd*-gnu)

+    link_all_deplibs_CXX=no

+  ;;

+  linux*)

+    link_all_deplibs_CXX=no

+  ;;

+  *)

+    export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'

+  ;;

+  esac

+

+echo "$as_me:$LINENO: result: $ld_shlibs_CXX" >&5

+echo "${ECHO_T}$ld_shlibs_CXX" >&6

+test "$ld_shlibs_CXX" = no && can_build_shared=no

+

+#

+# Do we need to explicitly link libc?

+#

+case "x$archive_cmds_need_lc_CXX" in

+x|xyes)

+  # Assume -lc should be added

+  archive_cmds_need_lc_CXX=yes

+

+  if test "$enable_shared" = yes && test "$GCC" = yes; then

+    case $archive_cmds_CXX in

+    *'~'*)

+      # FIXME: we may have to deal with multi-command sequences.

+      ;;

+    '$CC '*)

+      # Test whether the compiler implicitly links with -lc since on some

+      # systems, -lgcc has to come before -lc. If gcc already passes -lc

+      # to ld, don't add -lc before -lgcc.

+      echo "$as_me:$LINENO: checking whether -lc should be explicitly linked in" >&5

+echo $ECHO_N "checking whether -lc should be explicitly linked in... $ECHO_C" >&6

+      $rm conftest*

+      printf "$lt_simple_compile_test_code" > conftest.$ac_ext

+

+      if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } 2>conftest.err; then

+        soname=conftest

+        lib=conftest

+        libobjs=conftest.$ac_objext

+        deplibs=

+        wl=$lt_prog_compiler_wl_CXX

+	pic_flag=$lt_prog_compiler_pic_CXX

+        compiler_flags=-v

+        linker_flags=-v

+        verstring=

+        output_objdir=.

+        libname=conftest

+        lt_save_allow_undefined_flag=$allow_undefined_flag_CXX

+        allow_undefined_flag_CXX=

+        if { (eval echo "$as_me:$LINENO: \"$archive_cmds_CXX 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\"") >&5

+  (eval $archive_cmds_CXX 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }

+        then

+	  archive_cmds_need_lc_CXX=no

+        else

+	  archive_cmds_need_lc_CXX=yes

+        fi

+        allow_undefined_flag_CXX=$lt_save_allow_undefined_flag

+      else

+        cat conftest.err 1>&5

+      fi

+      $rm conftest*

+      echo "$as_me:$LINENO: result: $archive_cmds_need_lc_CXX" >&5

+echo "${ECHO_T}$archive_cmds_need_lc_CXX" >&6

+      ;;

+    esac

+  fi

+  ;;

+esac

+

+echo "$as_me:$LINENO: checking dynamic linker characteristics" >&5

+echo $ECHO_N "checking dynamic linker characteristics... $ECHO_C" >&6

+library_names_spec=

+libname_spec='lib$name'

+soname_spec=

+shrext_cmds=".so"

+postinstall_cmds=

+postuninstall_cmds=

+finish_cmds=

+finish_eval=

+shlibpath_var=

+shlibpath_overrides_runpath=unknown

+version_type=none

+dynamic_linker="$host_os ld.so"

+sys_lib_dlsearch_path_spec="/lib /usr/lib"

+if test "$GCC" = yes; then

+  sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`

+  if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then

+    # if the path contains ";" then we assume it to be the separator

+    # otherwise default to the standard path separator (i.e. ":") - it is

+    # assumed that no part of a normal pathname contains ";" but that should

+    # okay in the real world where ";" in dirpaths is itself problematic.

+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`

+  else

+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`

+  fi

+else

+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"

+fi

+need_lib_prefix=unknown

+hardcode_into_libs=no

+

+# when you set need_version to no, make sure it does not cause -set_version

+# flags to be left without arguments

+need_version=unknown

+

+case $host_os in

+aix3*)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'

+  shlibpath_var=LIBPATH

+

+  # AIX 3 has no versioning support, so we append a major version to the name.

+  soname_spec='${libname}${release}${shared_ext}$major'

+  ;;

+

+aix4* | aix5*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  hardcode_into_libs=yes

+  if test "$host_cpu" = ia64; then

+    # AIX 5 supports IA64

+    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'

+    shlibpath_var=LD_LIBRARY_PATH

+  else

+    # With GCC up to 2.95.x, collect2 would create an import file

+    # for dependence libraries.  The import file would start with

+    # the line `#! .'.  This would cause the generated library to

+    # depend on `.', always an invalid library.  This was fixed in

+    # development snapshots of GCC prior to 3.0.

+    case $host_os in

+      aix4 | aix4.[01] | aix4.[01].*)

+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'

+	   echo ' yes '

+	   echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then

+	:

+      else

+	can_build_shared=no

+      fi

+      ;;

+    esac

+    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct

+    # soname into executable. Probably we can add versioning support to

+    # collect2, so additional links can be useful in future.

+    if test "$aix_use_runtimelinking" = yes; then

+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so

+      # instead of lib<name>.a to let people know that these are not

+      # typical AIX shared libraries.

+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+    else

+      # We preserve .a as extension for shared libraries through AIX4.2

+      # and later when we are not doing run time linking.

+      library_names_spec='${libname}${release}.a $libname.a'

+      soname_spec='${libname}${release}${shared_ext}$major'

+    fi

+    shlibpath_var=LIBPATH

+  fi

+  ;;

+

+amigaos*)

+  library_names_spec='$libname.ixlibrary $libname.a'

+  # Create ${libname}_ixlibrary.a entries in /sys/libs.

+  finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'

+  ;;

+

+beos*)

+  library_names_spec='${libname}${shared_ext}'

+  dynamic_linker="$host_os ld.so"

+  shlibpath_var=LIBRARY_PATH

+  ;;

+

+bsdi[45]*)

+  version_type=linux

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"

+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"

+  # the default ld.so.conf also contains /usr/contrib/lib and

+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow

+  # libtool to hard-code these into programs

+  ;;

+

+cygwin* | mingw* | pw32*)

+  version_type=windows

+  shrext_cmds=".dll"

+  need_version=no

+  need_lib_prefix=no

+

+  case $GCC,$host_os in

+  yes,cygwin* | yes,mingw* | yes,pw32*)

+    library_names_spec='$libname.dll.a'

+    # DLL is installed to $(libdir)/../bin by postinstall_cmds

+    postinstall_cmds='base_file=`basename \${file}`~

+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~

+      dldir=$destdir/`dirname \$dlpath`~

+      test -d \$dldir || mkdir -p \$dldir~

+      $install_prog $dir/$dlname \$dldir/$dlname~

+      chmod a+x \$dldir/$dlname'

+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~

+      dlpath=$dir/\$dldll~

+       $rm \$dlpath'

+    shlibpath_overrides_runpath=yes

+

+    case $host_os in

+    cygwin*)

+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'

+      soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'

+      sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"

+      ;;

+    mingw*)

+      # MinGW DLLs use traditional 'lib' prefix

+      soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'

+      sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`

+      if echo "$sys_lib_search_path_spec" | grep ';[c-zC-Z]:/' >/dev/null; then

+        # It is most probably a Windows format PATH printed by

+        # mingw gcc, but we are running on Cygwin. Gcc prints its search

+        # path with ; separators, and with drive letters. We can handle the

+        # drive letters (cygwin fileutils understands them), so leave them,

+        # especially as we might pass files found there to a mingw objdump,

+        # which wouldn't understand a cygwinified path. Ahh.

+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`

+      else

+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`

+      fi

+      ;;

+    pw32*)

+      # pw32 DLLs use 'pw' prefix rather than 'lib'

+      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'

+      ;;

+    esac

+    ;;

+

+  *)

+    library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib'

+    ;;

+  esac

+  dynamic_linker='Win32 ld.exe'

+  # FIXME: first we should search . and the directory the executable is in

+  shlibpath_var=PATH

+  ;;

+

+darwin* | rhapsody*)

+  dynamic_linker="$host_os dyld"

+  version_type=darwin

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext'

+  soname_spec='${libname}${release}${major}$shared_ext'

+  shlibpath_overrides_runpath=yes

+  shlibpath_var=DYLD_LIBRARY_PATH

+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'

+  # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same.

+  if test "$GCC" = yes; then

+    sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"`

+  else

+    sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib'

+  fi

+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'

+  ;;

+

+dgux*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  ;;

+

+freebsd1*)

+  dynamic_linker=no

+  ;;

+

+kfreebsd*-gnu)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  dynamic_linker='GNU ld.so'

+  ;;

+

+freebsd* | dragonfly*)

+  # DragonFly does not have aout.  When/if they implement a new

+  # versioning mechanism, adjust this.

+  if test -x /usr/bin/objformat; then

+    objformat=`/usr/bin/objformat`

+  else

+    case $host_os in

+    freebsd[123]*) objformat=aout ;;

+    *) objformat=elf ;;

+    esac

+  fi

+  version_type=freebsd-$objformat

+  case $version_type in

+    freebsd-elf*)

+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'

+      need_version=no

+      need_lib_prefix=no

+      ;;

+    freebsd-*)

+      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'

+      need_version=yes

+      ;;

+  esac

+  shlibpath_var=LD_LIBRARY_PATH

+  case $host_os in

+  freebsd2*)

+    shlibpath_overrides_runpath=yes

+    ;;

+  freebsd3.[01]* | freebsdelf3.[01]*)

+    shlibpath_overrides_runpath=yes

+    hardcode_into_libs=yes

+    ;;

+  freebsd3.[2-9]* | freebsdelf3.[2-9]* | \

+  freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)

+    shlibpath_overrides_runpath=no

+    hardcode_into_libs=yes

+    ;;

+  freebsd*) # from 4.6 on

+    shlibpath_overrides_runpath=yes

+    hardcode_into_libs=yes

+    ;;

+  esac

+  ;;

+

+gnu*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  hardcode_into_libs=yes

+  ;;

+

+hpux9* | hpux10* | hpux11*)

+  # Give a soname corresponding to the major version so that dld.sl refuses to

+  # link against other versions.

+  version_type=sunos

+  need_lib_prefix=no

+  need_version=no

+  case $host_cpu in

+  ia64*)

+    shrext_cmds='.so'

+    hardcode_into_libs=yes

+    dynamic_linker="$host_os dld.so"

+    shlibpath_var=LD_LIBRARY_PATH

+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+    soname_spec='${libname}${release}${shared_ext}$major'

+    if test "X$HPUX_IA64_MODE" = X32; then

+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"

+    else

+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"

+    fi

+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec

+    ;;

+   hppa*64*)

+     shrext_cmds='.sl'

+     hardcode_into_libs=yes

+     dynamic_linker="$host_os dld.sl"

+     shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH

+     shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.

+     library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+     soname_spec='${libname}${release}${shared_ext}$major'

+     sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"

+     sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec

+     ;;

+   *)

+    shrext_cmds='.sl'

+    dynamic_linker="$host_os dld.sl"

+    shlibpath_var=SHLIB_PATH

+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+    soname_spec='${libname}${release}${shared_ext}$major'

+    ;;

+  esac

+  # HP-UX runs *really* slowly unless shared libraries are mode 555.

+  postinstall_cmds='chmod 555 $lib'

+  ;;

+

+interix3*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  ;;

+

+irix5* | irix6* | nonstopux*)

+  case $host_os in

+    nonstopux*) version_type=nonstopux ;;

+    *)

+	if test "$lt_cv_prog_gnu_ld" = yes; then

+		version_type=linux

+	else

+		version_type=irix

+	fi ;;

+  esac

+  need_lib_prefix=no

+  need_version=no

+  soname_spec='${libname}${release}${shared_ext}$major'

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'

+  case $host_os in

+  irix5* | nonstopux*)

+    libsuff= shlibsuff=

+    ;;

+  *)

+    case $LD in # libtool.m4 will add one of these switches to LD

+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")

+      libsuff= shlibsuff= libmagic=32-bit;;

+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")

+      libsuff=32 shlibsuff=N32 libmagic=N32;;

+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")

+      libsuff=64 shlibsuff=64 libmagic=64-bit;;

+    *) libsuff= shlibsuff= libmagic=never-match;;

+    esac

+    ;;

+  esac

+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH

+  shlibpath_overrides_runpath=no

+  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"

+  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"

+  hardcode_into_libs=yes

+  ;;

+

+# No shared lib support for Linux oldld, aout, or coff.

+linux*oldld* | linux*aout* | linux*coff*)

+  dynamic_linker=no

+  ;;

+

+# This must be Linux ELF.

+linux*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  # This implies no fast_install, which is unacceptable.

+  # Some rework will be needed to allow for fast_install

+  # before this can be enabled.

+  hardcode_into_libs=yes

+

+  # Append ld.so.conf contents to the search path

+  if test -f /etc/ld.so.conf; then

+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;/^$/d' | tr '\n' ' '`

+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"

+  fi

+

+  # We used to test for /lib/ld.so.1 and disable shared libraries on

+  # powerpc, because MkLinux only supported shared libraries with the

+  # GNU dynamic linker.  Since this was broken with cross compilers,

+  # most powerpc-linux boxes support dynamic linking these days and

+  # people can always --disable-shared, the test was removed, and we

+  # assume the GNU/Linux dynamic linker is in use.

+  dynamic_linker='GNU/Linux ld.so'

+  ;;

+

+netbsdelf*-gnu)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  dynamic_linker='NetBSD ld.elf_so'

+  ;;

+

+knetbsd*-gnu)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  dynamic_linker='GNU ld.so'

+  ;;

+

+netbsd*)

+  version_type=sunos

+  need_lib_prefix=no

+  need_version=no

+  if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'

+    dynamic_linker='NetBSD (a.out) ld.so'

+  else

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+    soname_spec='${libname}${release}${shared_ext}$major'

+    dynamic_linker='NetBSD ld.elf_so'

+  fi

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  hardcode_into_libs=yes

+  ;;

+

+newsos6)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  ;;

+

+nto-qnx*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  ;;

+

+openbsd*)

+  version_type=sunos

+  sys_lib_dlsearch_path_spec="/usr/lib"

+  need_lib_prefix=no

+  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.

+  case $host_os in

+    openbsd3.3 | openbsd3.3.*) need_version=yes ;;

+    *)                         need_version=no  ;;

+  esac

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

+    case $host_os in

+      openbsd2.[89] | openbsd2.[89].*)

+	shlibpath_overrides_runpath=no

+	;;

+      *)

+	shlibpath_overrides_runpath=yes

+	;;

+      esac

+  else

+    shlibpath_overrides_runpath=yes

+  fi

+  ;;

+

+os2*)

+  libname_spec='$name'

+  shrext_cmds=".dll"

+  need_lib_prefix=no

+  library_names_spec='$libname${shared_ext} $libname.a'

+  dynamic_linker='OS/2 ld.exe'

+  shlibpath_var=LIBPATH

+  ;;

+

+osf3* | osf4* | osf5*)

+  version_type=osf

+  need_lib_prefix=no

+  need_version=no

+  soname_spec='${libname}${release}${shared_ext}$major'

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  shlibpath_var=LD_LIBRARY_PATH

+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"

+  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"

+  ;;

+

+solaris*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  hardcode_into_libs=yes

+  # ldd complains unless libraries are executable

+  postinstall_cmds='chmod +x $lib'

+  ;;

+

+sunos4*)

+  version_type=sunos

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  if test "$with_gnu_ld" = yes; then

+    need_lib_prefix=no

+  fi

+  need_version=yes

+  ;;

+

+sysv4 | sysv4.3*)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  case $host_vendor in

+    sni)

+      shlibpath_overrides_runpath=no

+      need_lib_prefix=no

+      export_dynamic_flag_spec='${wl}-Blargedynsym'

+      runpath_var=LD_RUN_PATH

+      ;;

+    siemens)

+      need_lib_prefix=no

+      ;;

+    motorola)

+      need_lib_prefix=no

+      need_version=no

+      shlibpath_overrides_runpath=no

+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'

+      ;;

+  esac

+  ;;

+

+sysv4*MP*)

+  if test -d /usr/nec ;then

+    version_type=linux

+    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'

+    soname_spec='$libname${shared_ext}.$major'

+    shlibpath_var=LD_LIBRARY_PATH

+  fi

+  ;;

+

+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)

+  version_type=freebsd-elf

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  hardcode_into_libs=yes

+  if test "$with_gnu_ld" = yes; then

+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'

+    shlibpath_overrides_runpath=no

+  else

+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'

+    shlibpath_overrides_runpath=yes

+    case $host_os in

+      sco3.2v5*)

+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"

+	;;

+    esac

+  fi

+  sys_lib_dlsearch_path_spec='/usr/lib'

+  ;;

+

+uts4*)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  ;;

+

+*)

+  dynamic_linker=no

+  ;;

+esac

+echo "$as_me:$LINENO: result: $dynamic_linker" >&5

+echo "${ECHO_T}$dynamic_linker" >&6

+test "$dynamic_linker" = no && can_build_shared=no

+

+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"

+if test "$GCC" = yes; then

+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"

+fi

+

+echo "$as_me:$LINENO: checking how to hardcode library paths into programs" >&5

+echo $ECHO_N "checking how to hardcode library paths into programs... $ECHO_C" >&6

+hardcode_action_CXX=

+if test -n "$hardcode_libdir_flag_spec_CXX" || \

+   test -n "$runpath_var_CXX" || \

+   test "X$hardcode_automatic_CXX" = "Xyes" ; then

+

+  # We can hardcode non-existant directories.

+  if test "$hardcode_direct_CXX" != no &&

+     # If the only mechanism to avoid hardcoding is shlibpath_var, we

+     # have to relink, otherwise we might link with an installed library

+     # when we should be linking with a yet-to-be-installed one

+     ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, CXX)" != no &&

+     test "$hardcode_minus_L_CXX" != no; then

+    # Linking always hardcodes the temporary library directory.

+    hardcode_action_CXX=relink

+  else

+    # We can link without hardcoding, and we can hardcode nonexisting dirs.

+    hardcode_action_CXX=immediate

+  fi

+else

+  # We cannot hardcode anything, or else we can only hardcode existing

+  # directories.

+  hardcode_action_CXX=unsupported

+fi

+echo "$as_me:$LINENO: result: $hardcode_action_CXX" >&5

+echo "${ECHO_T}$hardcode_action_CXX" >&6

+

+if test "$hardcode_action_CXX" = relink; then

+  # Fast installation is not supported

+  enable_fast_install=no

+elif test "$shlibpath_overrides_runpath" = yes ||

+     test "$enable_shared" = no; then

+  # Fast installation is not necessary

+  enable_fast_install=needless

+fi

+

+

+# The else clause should only fire when bootstrapping the

+# libtool distribution, otherwise you forgot to ship ltmain.sh

+# with your package, and you will get complaints that there are

+# no rules to generate ltmain.sh.

+if test -f "$ltmain"; then

+  # See if we are running on zsh, and set the options which allow our commands through

+  # without removal of \ escapes.

+  if test -n "${ZSH_VERSION+set}" ; then

+    setopt NO_GLOB_SUBST

+  fi

+  # Now quote all the things that may contain metacharacters while being

+  # careful not to overquote the AC_SUBSTed values.  We take copies of the

+  # variables and quote the copies for generation of the libtool script.

+  for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC LTCFLAGS NM \

+    SED SHELL STRIP \

+    libname_spec library_names_spec soname_spec extract_expsyms_cmds \

+    old_striplib striplib file_magic_cmd finish_cmds finish_eval \

+    deplibs_check_method reload_flag reload_cmds need_locks \

+    lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \

+    lt_cv_sys_global_symbol_to_c_name_address \

+    sys_lib_search_path_spec sys_lib_dlsearch_path_spec \

+    old_postinstall_cmds old_postuninstall_cmds \

+    compiler_CXX \

+    CC_CXX \

+    LD_CXX \

+    lt_prog_compiler_wl_CXX \

+    lt_prog_compiler_pic_CXX \

+    lt_prog_compiler_static_CXX \

+    lt_prog_compiler_no_builtin_flag_CXX \

+    export_dynamic_flag_spec_CXX \

+    thread_safe_flag_spec_CXX \

+    whole_archive_flag_spec_CXX \

+    enable_shared_with_static_runtimes_CXX \

+    old_archive_cmds_CXX \

+    old_archive_from_new_cmds_CXX \

+    predep_objects_CXX \

+    postdep_objects_CXX \

+    predeps_CXX \

+    postdeps_CXX \

+    compiler_lib_search_path_CXX \

+    archive_cmds_CXX \

+    archive_expsym_cmds_CXX \

+    postinstall_cmds_CXX \

+    postuninstall_cmds_CXX \

+    old_archive_from_expsyms_cmds_CXX \

+    allow_undefined_flag_CXX \

+    no_undefined_flag_CXX \

+    export_symbols_cmds_CXX \

+    hardcode_libdir_flag_spec_CXX \

+    hardcode_libdir_flag_spec_ld_CXX \

+    hardcode_libdir_separator_CXX \

+    hardcode_automatic_CXX \

+    module_cmds_CXX \

+    module_expsym_cmds_CXX \

+    lt_cv_prog_compiler_c_o_CXX \

+    exclude_expsyms_CXX \

+    include_expsyms_CXX; do

+

+    case $var in

+    old_archive_cmds_CXX | \

+    old_archive_from_new_cmds_CXX | \

+    archive_cmds_CXX | \

+    archive_expsym_cmds_CXX | \

+    module_cmds_CXX | \

+    module_expsym_cmds_CXX | \

+    old_archive_from_expsyms_cmds_CXX | \

+    export_symbols_cmds_CXX | \

+    extract_expsyms_cmds | reload_cmds | finish_cmds | \

+    postinstall_cmds | postuninstall_cmds | \

+    old_postinstall_cmds | old_postuninstall_cmds | \

+    sys_lib_search_path_spec | sys_lib_dlsearch_path_spec)

+      # Double-quote double-evaled strings.

+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\""

+      ;;

+    *)

+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\""

+      ;;

+    esac

+  done

+

+  case $lt_echo in

+  *'\$0 --fallback-echo"')

+    lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'`

+    ;;

+  esac

+

+cfgfile="$ofile"

+

+  cat <<__EOF__ >> "$cfgfile"

+# ### BEGIN LIBTOOL TAG CONFIG: $tagname

+

+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:

+

+# Shell to use when invoking shell scripts.

+SHELL=$lt_SHELL

+

+# Whether or not to build shared libraries.

+build_libtool_libs=$enable_shared

+

+# Whether or not to build static libraries.

+build_old_libs=$enable_static

+

+# Whether or not to add -lc for building shared libraries.

+build_libtool_need_lc=$archive_cmds_need_lc_CXX

+

+# Whether or not to disallow shared libs when runtime libs are static

+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_CXX

+

+# Whether or not to optimize for fast installation.

+fast_install=$enable_fast_install

+

+# The host system.

+host_alias=$host_alias

+host=$host

+host_os=$host_os

+

+# The build system.

+build_alias=$build_alias

+build=$build

+build_os=$build_os

+

+# An echo program that does not interpret backslashes.

+echo=$lt_echo

+

+# The archiver.

+AR=$lt_AR

+AR_FLAGS=$lt_AR_FLAGS

+

+# A C compiler.

+LTCC=$lt_LTCC

+

+# LTCC compiler flags.

+LTCFLAGS=$lt_LTCFLAGS

+

+# A language-specific compiler.

+CC=$lt_compiler_CXX

+

+# Is the compiler the GNU C compiler?

+with_gcc=$GCC_CXX

+

+# An ERE matcher.

+EGREP=$lt_EGREP

+

+# The linker used to build libraries.

+LD=$lt_LD_CXX

+

+# Whether we need hard or soft links.

+LN_S=$lt_LN_S

+

+# A BSD-compatible nm program.

+NM=$lt_NM

+

+# A symbol stripping program

+STRIP=$lt_STRIP

+

+# Used to examine libraries when file_magic_cmd begins "file"

+MAGIC_CMD=$MAGIC_CMD

+

+# Used on cygwin: DLL creation program.

+DLLTOOL="$DLLTOOL"

+

+# Used on cygwin: object dumper.

+OBJDUMP="$OBJDUMP"

+

+# Used on cygwin: assembler.

+AS="$AS"

+

+# The name of the directory that contains temporary libtool files.

+objdir=$objdir

+

+# How to create reloadable object files.

+reload_flag=$lt_reload_flag

+reload_cmds=$lt_reload_cmds

+

+# How to pass a linker flag through the compiler.

+wl=$lt_lt_prog_compiler_wl_CXX

+

+# Object file suffix (normally "o").

+objext="$ac_objext"

+

+# Old archive suffix (normally "a").

+libext="$libext"

+

+# Shared library suffix (normally ".so").

+shrext_cmds='$shrext_cmds'

+

+# Executable file suffix (normally "").

+exeext="$exeext"

+

+# Additional compiler flags for building library objects.

+pic_flag=$lt_lt_prog_compiler_pic_CXX

+pic_mode=$pic_mode

+

+# What is the maximum length of a command?

+max_cmd_len=$lt_cv_sys_max_cmd_len

+

+# Does compiler simultaneously support -c and -o options?

+compiler_c_o=$lt_lt_cv_prog_compiler_c_o_CXX

+

+# Must we lock files when doing compilation?

+need_locks=$lt_need_locks

+

+# Do we need the lib prefix for modules?

+need_lib_prefix=$need_lib_prefix

+

+# Do we need a version for libraries?

+need_version=$need_version

+

+# Whether dlopen is supported.

+dlopen_support=$enable_dlopen

+

+# Whether dlopen of programs is supported.

+dlopen_self=$enable_dlopen_self

+

+# Whether dlopen of statically linked programs is supported.

+dlopen_self_static=$enable_dlopen_self_static

+

+# Compiler flag to prevent dynamic linking.

+link_static_flag=$lt_lt_prog_compiler_static_CXX

+

+# Compiler flag to turn off builtin functions.

+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_CXX

+

+# Compiler flag to allow reflexive dlopens.

+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_CXX

+

+# Compiler flag to generate shared objects directly from archives.

+whole_archive_flag_spec=$lt_whole_archive_flag_spec_CXX

+

+# Compiler flag to generate thread-safe objects.

+thread_safe_flag_spec=$lt_thread_safe_flag_spec_CXX

+

+# Library versioning type.

+version_type=$version_type

+

+# Format of library name prefix.

+libname_spec=$lt_libname_spec

+

+# List of archive names.  First name is the real one, the rest are links.

+# The last name is the one that the linker finds with -lNAME.

+library_names_spec=$lt_library_names_spec

+

+# The coded name of the library, if different from the real name.

+soname_spec=$lt_soname_spec

+

+# Commands used to build and install an old-style archive.

+RANLIB=$lt_RANLIB

+old_archive_cmds=$lt_old_archive_cmds_CXX

+old_postinstall_cmds=$lt_old_postinstall_cmds

+old_postuninstall_cmds=$lt_old_postuninstall_cmds

+

+# Create an old-style archive from a shared archive.

+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_CXX

+

+# Create a temporary old-style archive to link instead of a shared archive.

+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_CXX

+

+# Commands used to build and install a shared archive.

+archive_cmds=$lt_archive_cmds_CXX

+archive_expsym_cmds=$lt_archive_expsym_cmds_CXX

+postinstall_cmds=$lt_postinstall_cmds

+postuninstall_cmds=$lt_postuninstall_cmds

+

+# Commands used to build a loadable module (assumed same as above if empty)

+module_cmds=$lt_module_cmds_CXX

+module_expsym_cmds=$lt_module_expsym_cmds_CXX

+

+# Commands to strip libraries.

+old_striplib=$lt_old_striplib

+striplib=$lt_striplib

+

+# Dependencies to place before the objects being linked to create a

+# shared library.

+predep_objects=$lt_predep_objects_CXX

+

+# Dependencies to place after the objects being linked to create a

+# shared library.

+postdep_objects=$lt_postdep_objects_CXX

+

+# Dependencies to place before the objects being linked to create a

+# shared library.

+predeps=$lt_predeps_CXX

+

+# Dependencies to place after the objects being linked to create a

+# shared library.

+postdeps=$lt_postdeps_CXX

+

+# The library search path used internally by the compiler when linking

+# a shared library.

+compiler_lib_search_path=$lt_compiler_lib_search_path_CXX

+

+# Method to check whether dependent libraries are shared objects.

+deplibs_check_method=$lt_deplibs_check_method

+

+# Command to use when deplibs_check_method == file_magic.

+file_magic_cmd=$lt_file_magic_cmd

+

+# Flag that allows shared libraries with undefined symbols to be built.

+allow_undefined_flag=$lt_allow_undefined_flag_CXX

+

+# Flag that forces no undefined symbols.

+no_undefined_flag=$lt_no_undefined_flag_CXX

+

+# Commands used to finish a libtool library installation in a directory.

+finish_cmds=$lt_finish_cmds

+

+# Same as above, but a single script fragment to be evaled but not shown.

+finish_eval=$lt_finish_eval

+

+# Take the output of nm and produce a listing of raw symbols and C names.

+global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe

+

+# Transform the output of nm in a proper C declaration

+global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl

+

+# Transform the output of nm in a C name address pair

+global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address

+

+# This is the shared library runtime path variable.

+runpath_var=$runpath_var

+

+# This is the shared library path variable.

+shlibpath_var=$shlibpath_var

+

+# Is shlibpath searched before the hard-coded library search path?

+shlibpath_overrides_runpath=$shlibpath_overrides_runpath

+

+# How to hardcode a shared library path into an executable.

+hardcode_action=$hardcode_action_CXX

+

+# Whether we should hardcode library paths into libraries.

+hardcode_into_libs=$hardcode_into_libs

+

+# Flag to hardcode \$libdir into a binary during linking.

+# This must work even if \$libdir does not exist.

+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_CXX

+

+# If ld is used when linking, flag to hardcode \$libdir into

+# a binary during linking. This must work even if \$libdir does

+# not exist.

+hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld_CXX

+

+# Whether we need a single -rpath flag with a separated argument.

+hardcode_libdir_separator=$lt_hardcode_libdir_separator_CXX

+

+# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the

+# resulting binary.

+hardcode_direct=$hardcode_direct_CXX

+

+# Set to yes if using the -LDIR flag during linking hardcodes DIR into the

+# resulting binary.

+hardcode_minus_L=$hardcode_minus_L_CXX

+

+# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into

+# the resulting binary.

+hardcode_shlibpath_var=$hardcode_shlibpath_var_CXX

+

+# Set to yes if building a shared library automatically hardcodes DIR into the library

+# and all subsequent libraries and executables linked against it.

+hardcode_automatic=$hardcode_automatic_CXX

+

+# Variables whose values should be saved in libtool wrapper scripts and

+# restored at relink time.

+variables_saved_for_relink="$variables_saved_for_relink"

+

+# Whether libtool must link a program against all its dependency libraries.

+link_all_deplibs=$link_all_deplibs_CXX

+

+# Compile-time system search path for libraries

+sys_lib_search_path_spec=$lt_sys_lib_search_path_spec

+

+# Run-time system search path for libraries

+sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec

+

+# Fix the shell variable \$srcfile for the compiler.

+fix_srcfile_path="$fix_srcfile_path_CXX"

+

+# Set to yes if exported symbols are required.

+always_export_symbols=$always_export_symbols_CXX

+

+# The commands to list exported symbols.

+export_symbols_cmds=$lt_export_symbols_cmds_CXX

+

+# The commands to extract the exported symbol list from a shared archive.

+extract_expsyms_cmds=$lt_extract_expsyms_cmds

+

+# Symbols that should not be listed in the preloaded symbols.

+exclude_expsyms=$lt_exclude_expsyms_CXX

+

+# Symbols that must always be exported.

+include_expsyms=$lt_include_expsyms_CXX

+

+# ### END LIBTOOL TAG CONFIG: $tagname

+

+__EOF__

+

+

+else

+  # If there is no Makefile yet, we rely on a make rule to execute

+  # `config.status --recheck' to rerun these tests and create the

+  # libtool script then.

+  ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'`

+  if test -f "$ltmain_in"; then

+    test -f Makefile && make "$ltmain"

+  fi

+fi

+

+

+ac_ext=c

+ac_cpp='$CPP $CPPFLAGS'

+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_c_compiler_gnu

+

+CC=$lt_save_CC

+LDCXX=$LD

+LD=$lt_save_LD

+GCC=$lt_save_GCC

+with_gnu_ldcxx=$with_gnu_ld

+with_gnu_ld=$lt_save_with_gnu_ld

+lt_cv_path_LDCXX=$lt_cv_path_LD

+lt_cv_path_LD=$lt_save_path_LD

+lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld

+lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld

+

+	else

+	  tagname=""

+	fi

+	;;

+

+      F77)

+	if test -n "$F77" && test "X$F77" != "Xno"; then

+

+ac_ext=f

+ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'

+ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_f77_compiler_gnu

+

+

+archive_cmds_need_lc_F77=no

+allow_undefined_flag_F77=

+always_export_symbols_F77=no

+archive_expsym_cmds_F77=

+export_dynamic_flag_spec_F77=

+hardcode_direct_F77=no

+hardcode_libdir_flag_spec_F77=

+hardcode_libdir_flag_spec_ld_F77=

+hardcode_libdir_separator_F77=

+hardcode_minus_L_F77=no

+hardcode_automatic_F77=no

+module_cmds_F77=

+module_expsym_cmds_F77=

+link_all_deplibs_F77=unknown

+old_archive_cmds_F77=$old_archive_cmds

+no_undefined_flag_F77=

+whole_archive_flag_spec_F77=

+enable_shared_with_static_runtimes_F77=no

+

+# Source file extension for f77 test sources.

+ac_ext=f

+

+# Object file extension for compiled f77 test sources.

+objext=o

+objext_F77=$objext

+

+# Code to be used in simple compile tests

+lt_simple_compile_test_code="      subroutine t\n      return\n      end\n"

+

+# Code to be used in simple link tests

+lt_simple_link_test_code="      program t\n      end\n"

+

+# ltmain only uses $CC for tagged configurations so make sure $CC is set.

+

+# If no C compiler was specified, use CC.

+LTCC=${LTCC-"$CC"}

+

+# If no C compiler flags were specified, use CFLAGS.

+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}

+

+# Allow CC to be a program name with arguments.

+compiler=$CC

+

+

+# save warnings/boilerplate of simple test code

+ac_outfile=conftest.$ac_objext

+printf "$lt_simple_compile_test_code" >conftest.$ac_ext

+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err

+_lt_compiler_boilerplate=`cat conftest.err`

+$rm conftest*

+

+ac_outfile=conftest.$ac_objext

+printf "$lt_simple_link_test_code" >conftest.$ac_ext

+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err

+_lt_linker_boilerplate=`cat conftest.err`

+$rm conftest*

+

+

+# Allow CC to be a program name with arguments.

+lt_save_CC="$CC"

+CC=${F77-"f77"}

+compiler=$CC

+compiler_F77=$CC

+for cc_temp in $compiler""; do

+  case $cc_temp in

+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;

+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;

+    \-*) ;;

+    *) break;;

+  esac

+done

+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`

+

+

+echo "$as_me:$LINENO: checking if libtool supports shared libraries" >&5

+echo $ECHO_N "checking if libtool supports shared libraries... $ECHO_C" >&6

+echo "$as_me:$LINENO: result: $can_build_shared" >&5

+echo "${ECHO_T}$can_build_shared" >&6

+

+echo "$as_me:$LINENO: checking whether to build shared libraries" >&5

+echo $ECHO_N "checking whether to build shared libraries... $ECHO_C" >&6

+test "$can_build_shared" = "no" && enable_shared=no

+

+# On AIX, shared libraries and static libraries use the same namespace, and

+# are all built from PIC.

+case $host_os in

+aix3*)

+  test "$enable_shared" = yes && enable_static=no

+  if test -n "$RANLIB"; then

+    archive_cmds="$archive_cmds~\$RANLIB \$lib"

+    postinstall_cmds='$RANLIB $lib'

+  fi

+  ;;

+aix4* | aix5*)

+  if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then

+    test "$enable_shared" = yes && enable_static=no

+  fi

+  ;;

+esac

+echo "$as_me:$LINENO: result: $enable_shared" >&5

+echo "${ECHO_T}$enable_shared" >&6

+

+echo "$as_me:$LINENO: checking whether to build static libraries" >&5

+echo $ECHO_N "checking whether to build static libraries... $ECHO_C" >&6

+# Make sure either enable_shared or enable_static is yes.

+test "$enable_shared" = yes || enable_static=yes

+echo "$as_me:$LINENO: result: $enable_static" >&5

+echo "${ECHO_T}$enable_static" >&6

+

+GCC_F77="$G77"

+LD_F77="$LD"

+

+lt_prog_compiler_wl_F77=

+lt_prog_compiler_pic_F77=

+lt_prog_compiler_static_F77=

+

+echo "$as_me:$LINENO: checking for $compiler option to produce PIC" >&5

+echo $ECHO_N "checking for $compiler option to produce PIC... $ECHO_C" >&6

+

+  if test "$GCC" = yes; then

+    lt_prog_compiler_wl_F77='-Wl,'

+    lt_prog_compiler_static_F77='-static'

+

+    case $host_os in

+      aix*)

+      # All AIX code is PIC.

+      if test "$host_cpu" = ia64; then

+	# AIX 5 now supports IA64 processor

+	lt_prog_compiler_static_F77='-Bstatic'

+      fi

+      ;;

+

+    amigaos*)

+      # FIXME: we need at least 68020 code to build shared libraries, but

+      # adding the `-m68020' flag to GCC prevents building anything better,

+      # like `-m68040'.

+      lt_prog_compiler_pic_F77='-m68020 -resident32 -malways-restore-a4'

+      ;;

+

+    beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)

+      # PIC is the default for these OSes.

+      ;;

+

+    mingw* | pw32* | os2*)

+      # This hack is so that the source file can tell whether it is being

+      # built for inclusion in a dll (and should export symbols for example).

+      lt_prog_compiler_pic_F77='-DDLL_EXPORT'

+      ;;

+

+    darwin* | rhapsody*)

+      # PIC is the default on this platform

+      # Common symbols not allowed in MH_DYLIB files

+      lt_prog_compiler_pic_F77='-fno-common'

+      ;;

+

+    interix3*)

+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.

+      # Instead, we relocate shared libraries at runtime.

+      ;;

+

+    msdosdjgpp*)

+      # Just because we use GCC doesn't mean we suddenly get shared libraries

+      # on systems that don't support them.

+      lt_prog_compiler_can_build_shared_F77=no

+      enable_shared=no

+      ;;

+

+    sysv4*MP*)

+      if test -d /usr/nec; then

+	lt_prog_compiler_pic_F77=-Kconform_pic

+      fi

+      ;;

+

+    hpux*)

+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but

+      # not for PA HP-UX.

+      case $host_cpu in

+      hppa*64*|ia64*)

+	# +Z the default

+	;;

+      *)

+	lt_prog_compiler_pic_F77='-fPIC'

+	;;

+      esac

+      ;;

+

+    *)

+      lt_prog_compiler_pic_F77='-fPIC'

+      ;;

+    esac

+  else

+    # PORTME Check for flag to pass linker flags through the system compiler.

+    case $host_os in

+    aix*)

+      lt_prog_compiler_wl_F77='-Wl,'

+      if test "$host_cpu" = ia64; then

+	# AIX 5 now supports IA64 processor

+	lt_prog_compiler_static_F77='-Bstatic'

+      else

+	lt_prog_compiler_static_F77='-bnso -bI:/lib/syscalls.exp'

+      fi

+      ;;

+      darwin*)

+        # PIC is the default on this platform

+        # Common symbols not allowed in MH_DYLIB files

+       case $cc_basename in

+         xlc*)

+         lt_prog_compiler_pic_F77='-qnocommon'

+         lt_prog_compiler_wl_F77='-Wl,'

+         ;;

+       esac

+       ;;

+

+    mingw* | pw32* | os2*)

+      # This hack is so that the source file can tell whether it is being

+      # built for inclusion in a dll (and should export symbols for example).

+      lt_prog_compiler_pic_F77='-DDLL_EXPORT'

+      ;;

+

+    hpux9* | hpux10* | hpux11*)

+      lt_prog_compiler_wl_F77='-Wl,'

+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but

+      # not for PA HP-UX.

+      case $host_cpu in

+      hppa*64*|ia64*)

+	# +Z the default

+	;;

+      *)

+	lt_prog_compiler_pic_F77='+Z'

+	;;

+      esac

+      # Is there a better lt_prog_compiler_static that works with the bundled CC?

+      lt_prog_compiler_static_F77='${wl}-a ${wl}archive'

+      ;;

+

+    irix5* | irix6* | nonstopux*)

+      lt_prog_compiler_wl_F77='-Wl,'

+      # PIC (with -KPIC) is the default.

+      lt_prog_compiler_static_F77='-non_shared'

+      ;;

+

+    newsos6)

+      lt_prog_compiler_pic_F77='-KPIC'

+      lt_prog_compiler_static_F77='-Bstatic'

+      ;;

+

+    linux*)

+      case $cc_basename in

+      icc* | ecc*)

+	lt_prog_compiler_wl_F77='-Wl,'

+	lt_prog_compiler_pic_F77='-KPIC'

+	lt_prog_compiler_static_F77='-static'

+        ;;

+      pgcc* | pgf77* | pgf90* | pgf95*)

+        # Portland Group compilers (*not* the Pentium gcc compiler,

+	# which looks to be a dead project)

+	lt_prog_compiler_wl_F77='-Wl,'

+	lt_prog_compiler_pic_F77='-fpic'

+	lt_prog_compiler_static_F77='-Bstatic'

+        ;;

+      ccc*)

+        lt_prog_compiler_wl_F77='-Wl,'

+        # All Alpha code is PIC.

+        lt_prog_compiler_static_F77='-non_shared'

+        ;;

+      esac

+      ;;

+

+    osf3* | osf4* | osf5*)

+      lt_prog_compiler_wl_F77='-Wl,'

+      # All OSF/1 code is PIC.

+      lt_prog_compiler_static_F77='-non_shared'

+      ;;

+

+    solaris*)

+      lt_prog_compiler_pic_F77='-KPIC'

+      lt_prog_compiler_static_F77='-Bstatic'

+      case $cc_basename in

+      f77* | f90* | f95*)

+	lt_prog_compiler_wl_F77='-Qoption ld ';;

+      *)

+	lt_prog_compiler_wl_F77='-Wl,';;

+      esac

+      ;;

+

+    sunos4*)

+      lt_prog_compiler_wl_F77='-Qoption ld '

+      lt_prog_compiler_pic_F77='-PIC'

+      lt_prog_compiler_static_F77='-Bstatic'

+      ;;

+

+    sysv4 | sysv4.2uw2* | sysv4.3*)

+      lt_prog_compiler_wl_F77='-Wl,'

+      lt_prog_compiler_pic_F77='-KPIC'

+      lt_prog_compiler_static_F77='-Bstatic'

+      ;;

+

+    sysv4*MP*)

+      if test -d /usr/nec ;then

+	lt_prog_compiler_pic_F77='-Kconform_pic'

+	lt_prog_compiler_static_F77='-Bstatic'

+      fi

+      ;;

+

+    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)

+      lt_prog_compiler_wl_F77='-Wl,'

+      lt_prog_compiler_pic_F77='-KPIC'

+      lt_prog_compiler_static_F77='-Bstatic'

+      ;;

+

+    unicos*)

+      lt_prog_compiler_wl_F77='-Wl,'

+      lt_prog_compiler_can_build_shared_F77=no

+      ;;

+

+    uts4*)

+      lt_prog_compiler_pic_F77='-pic'

+      lt_prog_compiler_static_F77='-Bstatic'

+      ;;

+

+    *)

+      lt_prog_compiler_can_build_shared_F77=no

+      ;;

+    esac

+  fi

+

+echo "$as_me:$LINENO: result: $lt_prog_compiler_pic_F77" >&5

+echo "${ECHO_T}$lt_prog_compiler_pic_F77" >&6

+

+#

+# Check to make sure the PIC flag actually works.

+#

+if test -n "$lt_prog_compiler_pic_F77"; then

+

+echo "$as_me:$LINENO: checking if $compiler PIC flag $lt_prog_compiler_pic_F77 works" >&5

+echo $ECHO_N "checking if $compiler PIC flag $lt_prog_compiler_pic_F77 works... $ECHO_C" >&6

+if test "${lt_prog_compiler_pic_works_F77+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  lt_prog_compiler_pic_works_F77=no

+  ac_outfile=conftest.$ac_objext

+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext

+   lt_compiler_flag="$lt_prog_compiler_pic_F77"

+   # Insert the option either (1) after the last *FLAGS variable, or

+   # (2) before a word containing "conftest.", or (3) at the end.

+   # Note that $ac_compile itself does not contain backslashes and begins

+   # with a dollar sign (not a hyphen), so the echo should work correctly.

+   # The option is referenced via a variable to avoid confusing sed.

+   lt_compile=`echo "$ac_compile" | $SED \

+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \

+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \

+   -e 's:$: $lt_compiler_flag:'`

+   (eval echo "\"\$as_me:13195: $lt_compile\"" >&5)

+   (eval "$lt_compile" 2>conftest.err)

+   ac_status=$?

+   cat conftest.err >&5

+   echo "$as_me:13199: \$? = $ac_status" >&5

+   if (exit $ac_status) && test -s "$ac_outfile"; then

+     # The compiler can only warn and ignore the option if not recognized

+     # So say no if there are warnings other than the usual output.

+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp

+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then

+       lt_prog_compiler_pic_works_F77=yes

+     fi

+   fi

+   $rm conftest*

+

+fi

+echo "$as_me:$LINENO: result: $lt_prog_compiler_pic_works_F77" >&5

+echo "${ECHO_T}$lt_prog_compiler_pic_works_F77" >&6

+

+if test x"$lt_prog_compiler_pic_works_F77" = xyes; then

+    case $lt_prog_compiler_pic_F77 in

+     "" | " "*) ;;

+     *) lt_prog_compiler_pic_F77=" $lt_prog_compiler_pic_F77" ;;

+     esac

+else

+    lt_prog_compiler_pic_F77=

+     lt_prog_compiler_can_build_shared_F77=no

+fi

+

+fi

+case $host_os in

+  # For platforms which do not support PIC, -DPIC is meaningless:

+  *djgpp*)

+    lt_prog_compiler_pic_F77=

+    ;;

+  *)

+    lt_prog_compiler_pic_F77="$lt_prog_compiler_pic_F77"

+    ;;

+esac

+

+#

+# Check to make sure the static flag actually works.

+#

+wl=$lt_prog_compiler_wl_F77 eval lt_tmp_static_flag=\"$lt_prog_compiler_static_F77\"

+echo "$as_me:$LINENO: checking if $compiler static flag $lt_tmp_static_flag works" >&5

+echo $ECHO_N "checking if $compiler static flag $lt_tmp_static_flag works... $ECHO_C" >&6

+if test "${lt_prog_compiler_static_works_F77+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  lt_prog_compiler_static_works_F77=no

+   save_LDFLAGS="$LDFLAGS"

+   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"

+   printf "$lt_simple_link_test_code" > conftest.$ac_ext

+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then

+     # The linker can only warn and ignore the option if not recognized

+     # So say no if there are warnings

+     if test -s conftest.err; then

+       # Append any errors to the config.log.

+       cat conftest.err 1>&5

+       $echo "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp

+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

+       if diff conftest.exp conftest.er2 >/dev/null; then

+         lt_prog_compiler_static_works_F77=yes

+       fi

+     else

+       lt_prog_compiler_static_works_F77=yes

+     fi

+   fi

+   $rm conftest*

+   LDFLAGS="$save_LDFLAGS"

+

+fi

+echo "$as_me:$LINENO: result: $lt_prog_compiler_static_works_F77" >&5

+echo "${ECHO_T}$lt_prog_compiler_static_works_F77" >&6

+

+if test x"$lt_prog_compiler_static_works_F77" = xyes; then

+    :

+else

+    lt_prog_compiler_static_F77=

+fi

+

+

+echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5

+echo $ECHO_N "checking if $compiler supports -c -o file.$ac_objext... $ECHO_C" >&6

+if test "${lt_cv_prog_compiler_c_o_F77+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  lt_cv_prog_compiler_c_o_F77=no

+   $rm -r conftest 2>/dev/null

+   mkdir conftest

+   cd conftest

+   mkdir out

+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext

+

+   lt_compiler_flag="-o out/conftest2.$ac_objext"

+   # Insert the option either (1) after the last *FLAGS variable, or

+   # (2) before a word containing "conftest.", or (3) at the end.

+   # Note that $ac_compile itself does not contain backslashes and begins

+   # with a dollar sign (not a hyphen), so the echo should work correctly.

+   lt_compile=`echo "$ac_compile" | $SED \

+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \

+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \

+   -e 's:$: $lt_compiler_flag:'`

+   (eval echo "\"\$as_me:13299: $lt_compile\"" >&5)

+   (eval "$lt_compile" 2>out/conftest.err)

+   ac_status=$?

+   cat out/conftest.err >&5

+   echo "$as_me:13303: \$? = $ac_status" >&5

+   if (exit $ac_status) && test -s out/conftest2.$ac_objext

+   then

+     # The compiler can only warn and ignore the option if not recognized

+     # So say no if there are warnings

+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp

+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2

+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then

+       lt_cv_prog_compiler_c_o_F77=yes

+     fi

+   fi

+   chmod u+w . 2>&5

+   $rm conftest*

+   # SGI C++ compiler will create directory out/ii_files/ for

+   # template instantiation

+   test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files

+   $rm out/* && rmdir out

+   cd ..

+   rmdir conftest

+   $rm conftest*

+

+fi

+echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_c_o_F77" >&5

+echo "${ECHO_T}$lt_cv_prog_compiler_c_o_F77" >&6

+

+

+hard_links="nottested"

+if test "$lt_cv_prog_compiler_c_o_F77" = no && test "$need_locks" != no; then

+  # do not overwrite the value of need_locks provided by the user

+  echo "$as_me:$LINENO: checking if we can lock with hard links" >&5

+echo $ECHO_N "checking if we can lock with hard links... $ECHO_C" >&6

+  hard_links=yes

+  $rm conftest*

+  ln conftest.a conftest.b 2>/dev/null && hard_links=no

+  touch conftest.a

+  ln conftest.a conftest.b 2>&5 || hard_links=no

+  ln conftest.a conftest.b 2>/dev/null && hard_links=no

+  echo "$as_me:$LINENO: result: $hard_links" >&5

+echo "${ECHO_T}$hard_links" >&6

+  if test "$hard_links" = no; then

+    { echo "$as_me:$LINENO: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5

+echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}

+    need_locks=warn

+  fi

+else

+  need_locks=no

+fi

+

+echo "$as_me:$LINENO: checking whether the $compiler linker ($LD) supports shared libraries" >&5

+echo $ECHO_N "checking whether the $compiler linker ($LD) supports shared libraries... $ECHO_C" >&6

+

+  runpath_var=

+  allow_undefined_flag_F77=

+  enable_shared_with_static_runtimes_F77=no

+  archive_cmds_F77=

+  archive_expsym_cmds_F77=

+  old_archive_From_new_cmds_F77=

+  old_archive_from_expsyms_cmds_F77=

+  export_dynamic_flag_spec_F77=

+  whole_archive_flag_spec_F77=

+  thread_safe_flag_spec_F77=

+  hardcode_libdir_flag_spec_F77=

+  hardcode_libdir_flag_spec_ld_F77=

+  hardcode_libdir_separator_F77=

+  hardcode_direct_F77=no

+  hardcode_minus_L_F77=no

+  hardcode_shlibpath_var_F77=unsupported

+  link_all_deplibs_F77=unknown

+  hardcode_automatic_F77=no

+  module_cmds_F77=

+  module_expsym_cmds_F77=

+  always_export_symbols_F77=no

+  export_symbols_cmds_F77='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'

+  # include_expsyms should be a list of space-separated symbols to be *always*

+  # included in the symbol list

+  include_expsyms_F77=

+  # exclude_expsyms can be an extended regexp of symbols to exclude

+  # it will be wrapped by ` (' and `)$', so one must not match beginning or

+  # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',

+  # as well as any symbol that contains `d'.

+  exclude_expsyms_F77="_GLOBAL_OFFSET_TABLE_"

+  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out

+  # platforms (ab)use it in PIC code, but their linkers get confused if

+  # the symbol is explicitly referenced.  Since portable code cannot

+  # rely on this symbol name, it's probably fine to never include it in

+  # preloaded symbol tables.

+  extract_expsyms_cmds=

+  # Just being paranoid about ensuring that cc_basename is set.

+  for cc_temp in $compiler""; do

+  case $cc_temp in

+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;

+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;

+    \-*) ;;

+    *) break;;

+  esac

+done

+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`

+

+  case $host_os in

+  cygwin* | mingw* | pw32*)

+    # FIXME: the MSVC++ port hasn't been tested in a loooong time

+    # When not using gcc, we currently assume that we are using

+    # Microsoft Visual C++.

+    if test "$GCC" != yes; then

+      with_gnu_ld=no

+    fi

+    ;;

+  interix*)

+    # we just hope/assume this is gcc and not c89 (= MSVC++)

+    with_gnu_ld=yes

+    ;;

+  openbsd*)

+    with_gnu_ld=no

+    ;;

+  esac

+

+  ld_shlibs_F77=yes

+  if test "$with_gnu_ld" = yes; then

+    # If archive_cmds runs LD, not CC, wlarc should be empty

+    wlarc='${wl}'

+

+    # Set some defaults for GNU ld with shared library support. These

+    # are reset later if shared libraries are not supported. Putting them

+    # here allows them to be overridden if necessary.

+    runpath_var=LD_RUN_PATH

+    hardcode_libdir_flag_spec_F77='${wl}--rpath ${wl}$libdir'

+    export_dynamic_flag_spec_F77='${wl}--export-dynamic'

+    # ancient GNU ld didn't support --whole-archive et. al.

+    if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then

+	whole_archive_flag_spec_F77="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'

+      else

+  	whole_archive_flag_spec_F77=

+    fi

+    supports_anon_versioning=no

+    case `$LD -v 2>/dev/null` in

+      *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11

+      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...

+      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...

+      *\ 2.11.*) ;; # other 2.11 versions

+      *) supports_anon_versioning=yes ;;

+    esac

+

+    # See if GNU ld supports shared libraries.

+    case $host_os in

+    aix3* | aix4* | aix5*)

+      # On AIX/PPC, the GNU linker is very broken

+      if test "$host_cpu" != ia64; then

+	ld_shlibs_F77=no

+	cat <<EOF 1>&2

+

+*** Warning: the GNU linker, at least up to release 2.9.1, is reported

+*** to be unable to reliably create shared libraries on AIX.

+*** Therefore, libtool is disabling shared libraries support.  If you

+*** really care for shared libraries, you may want to modify your PATH

+*** so that a non-GNU linker is found, and then restart.

+

+EOF

+      fi

+      ;;

+

+    amigaos*)

+      archive_cmds_F77='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'

+      hardcode_libdir_flag_spec_F77='-L$libdir'

+      hardcode_minus_L_F77=yes

+

+      # Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports

+      # that the semantics of dynamic libraries on AmigaOS, at least up

+      # to version 4, is to share data among multiple programs linked

+      # with the same dynamic library.  Since this doesn't match the

+      # behavior of shared libraries on other platforms, we can't use

+      # them.

+      ld_shlibs_F77=no

+      ;;

+

+    beos*)

+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	allow_undefined_flag_F77=unsupported

+	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc

+	# support --undefined.  This deserves some investigation.  FIXME

+	archive_cmds_F77='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+      else

+	ld_shlibs_F77=no

+      fi

+      ;;

+

+    cygwin* | mingw* | pw32*)

+      # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, F77) is actually meaningless,

+      # as there is no search path for DLLs.

+      hardcode_libdir_flag_spec_F77='-L$libdir'

+      allow_undefined_flag_F77=unsupported

+      always_export_symbols_F77=no

+      enable_shared_with_static_runtimes_F77=yes

+      export_symbols_cmds_F77='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS] /s/.* \([^ ]*\)/\1 DATA/'\'' | $SED -e '\''/^[AITW] /s/.* //'\'' | sort | uniq > $export_symbols'

+

+      if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then

+        archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'

+	# If the export-symbols file already is a .def file (1st line

+	# is EXPORTS), use it as is; otherwise, prepend...

+	archive_expsym_cmds_F77='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then

+	  cp $export_symbols $output_objdir/$soname.def;

+	else

+	  echo EXPORTS > $output_objdir/$soname.def;

+	  cat $export_symbols >> $output_objdir/$soname.def;

+	fi~

+	$CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'

+      else

+	ld_shlibs_F77=no

+      fi

+      ;;

+

+    interix3*)

+      hardcode_direct_F77=no

+      hardcode_shlibpath_var_F77=no

+      hardcode_libdir_flag_spec_F77='${wl}-rpath,$libdir'

+      export_dynamic_flag_spec_F77='${wl}-E'

+      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.

+      # Instead, shared libraries are loaded at an image base (0x10000000 by

+      # default) and relocated if they conflict, which is a slow very memory

+      # consuming and fragmenting process.  To avoid this, we pick a random,

+      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link

+      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.

+      archive_cmds_F77='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'

+      archive_expsym_cmds_F77='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'

+      ;;

+

+    linux*)

+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	tmp_addflag=

+	case $cc_basename,$host_cpu in

+	pgcc*)				# Portland Group C compiler

+	  whole_archive_flag_spec_F77='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'

+	  tmp_addflag=' $pic_flag'

+	  ;;

+	pgf77* | pgf90* | pgf95*)	# Portland Group f77 and f90 compilers

+	  whole_archive_flag_spec_F77='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'

+	  tmp_addflag=' $pic_flag -Mnomain' ;;

+	ecc*,ia64* | icc*,ia64*)		# Intel C compiler on ia64

+	  tmp_addflag=' -i_dynamic' ;;

+	efc*,ia64* | ifort*,ia64*)	# Intel Fortran compiler on ia64

+	  tmp_addflag=' -i_dynamic -nofor_main' ;;

+	ifc* | ifort*)			# Intel Fortran compiler

+	  tmp_addflag=' -nofor_main' ;;

+	esac

+	archive_cmds_F77='$CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+

+	if test $supports_anon_versioning = yes; then

+	  archive_expsym_cmds_F77='$echo "{ global:" > $output_objdir/$libname.ver~

+  cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~

+  $echo "local: *; };" >> $output_objdir/$libname.ver~

+	  $CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'

+	fi

+	link_all_deplibs_F77=no

+      else

+	ld_shlibs_F77=no

+      fi

+      ;;

+

+    netbsd* | netbsdelf*-gnu | knetbsd*-gnu)

+      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

+	archive_cmds_F77='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'

+	wlarc=

+      else

+	archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+	archive_expsym_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+      fi

+      ;;

+

+    solaris*)

+      if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then

+	ld_shlibs_F77=no

+	cat <<EOF 1>&2

+

+*** Warning: The releases 2.8.* of the GNU linker cannot reliably

+*** create shared libraries on Solaris systems.  Therefore, libtool

+*** is disabling shared libraries support.  We urge you to upgrade GNU

+*** binutils to release 2.9.1 or newer.  Another option is to modify

+*** your PATH or compiler configuration so that the native linker is

+*** used, and then restart.

+

+EOF

+      elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+	archive_expsym_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+      else

+	ld_shlibs_F77=no

+      fi

+      ;;

+

+    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)

+      case `$LD -v 2>&1` in

+        *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)

+	ld_shlibs_F77=no

+	cat <<_LT_EOF 1>&2

+

+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not

+*** reliably create shared libraries on SCO systems.  Therefore, libtool

+*** is disabling shared libraries support.  We urge you to upgrade GNU

+*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify

+*** your PATH or compiler configuration so that the native linker is

+*** used, and then restart.

+

+_LT_EOF

+	;;

+	*)

+	  if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	    hardcode_libdir_flag_spec_F77='`test -z "$SCOABSPATH" && echo ${wl}-rpath,$libdir`'

+	    archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib'

+	    archive_expsym_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname,-retain-symbols-file,$export_symbols -o $lib'

+	  else

+	    ld_shlibs_F77=no

+	  fi

+	;;

+      esac

+      ;;

+

+    sunos4*)

+      archive_cmds_F77='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'

+      wlarc=

+      hardcode_direct_F77=yes

+      hardcode_shlibpath_var_F77=no

+      ;;

+

+    *)

+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+	archive_expsym_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+      else

+	ld_shlibs_F77=no

+      fi

+      ;;

+    esac

+

+    if test "$ld_shlibs_F77" = no; then

+      runpath_var=

+      hardcode_libdir_flag_spec_F77=

+      export_dynamic_flag_spec_F77=

+      whole_archive_flag_spec_F77=

+    fi

+  else

+    # PORTME fill in a description of your system's linker (not GNU ld)

+    case $host_os in

+    aix3*)

+      allow_undefined_flag_F77=unsupported

+      always_export_symbols_F77=yes

+      archive_expsym_cmds_F77='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'

+      # Note: this linker hardcodes the directories in LIBPATH if there

+      # are no directories specified by -L.

+      hardcode_minus_L_F77=yes

+      if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then

+	# Neither direct hardcoding nor static linking is supported with a

+	# broken collect2.

+	hardcode_direct_F77=unsupported

+      fi

+      ;;

+

+    aix4* | aix5*)

+      if test "$host_cpu" = ia64; then

+	# On IA64, the linker does run time linking by default, so we don't

+	# have to do anything special.

+	aix_use_runtimelinking=no

+	exp_sym_flag='-Bexport'

+	no_entry_flag=""

+      else

+	# If we're using GNU nm, then we don't want the "-C" option.

+	# -C means demangle to AIX nm, but means don't demangle with GNU nm

+	if $NM -V 2>&1 | grep 'GNU' > /dev/null; then

+	  export_symbols_cmds_F77='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols'

+	else

+	  export_symbols_cmds_F77='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols'

+	fi

+	aix_use_runtimelinking=no

+

+	# Test if we are trying to use run time linking or normal

+	# AIX style linking. If -brtl is somewhere in LDFLAGS, we

+	# need to do runtime linking.

+	case $host_os in aix4.[23]|aix4.[23].*|aix5*)

+	  for ld_flag in $LDFLAGS; do

+  	  if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then

+  	    aix_use_runtimelinking=yes

+  	    break

+  	  fi

+	  done

+	  ;;

+	esac

+

+	exp_sym_flag='-bexport'

+	no_entry_flag='-bnoentry'

+      fi

+

+      # When large executables or shared objects are built, AIX ld can

+      # have problems creating the table of contents.  If linking a library

+      # or program results in "error TOC overflow" add -mminimal-toc to

+      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not

+      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.

+

+      archive_cmds_F77=''

+      hardcode_direct_F77=yes

+      hardcode_libdir_separator_F77=':'

+      link_all_deplibs_F77=yes

+

+      if test "$GCC" = yes; then

+	case $host_os in aix4.[012]|aix4.[012].*)

+	# We only want to do this on AIX 4.2 and lower, the check

+	# below for broken collect2 doesn't work under 4.3+

+	  collect2name=`${CC} -print-prog-name=collect2`

+	  if test -f "$collect2name" && \

+  	   strings "$collect2name" | grep resolve_lib_name >/dev/null

+	  then

+  	  # We have reworked collect2

+  	  hardcode_direct_F77=yes

+	  else

+  	  # We have old collect2

+  	  hardcode_direct_F77=unsupported

+  	  # It fails to find uninstalled libraries when the uninstalled

+  	  # path is not listed in the libpath.  Setting hardcode_minus_L

+  	  # to unsupported forces relinking

+  	  hardcode_minus_L_F77=yes

+  	  hardcode_libdir_flag_spec_F77='-L$libdir'

+  	  hardcode_libdir_separator_F77=

+	  fi

+	  ;;

+	esac

+	shared_flag='-shared'

+	if test "$aix_use_runtimelinking" = yes; then

+	  shared_flag="$shared_flag "'${wl}-G'

+	fi

+      else

+	# not using gcc

+	if test "$host_cpu" = ia64; then

+  	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release

+  	# chokes on -Wl,-G. The following line is correct:

+	  shared_flag='-G'

+	else

+	  if test "$aix_use_runtimelinking" = yes; then

+	    shared_flag='${wl}-G'

+	  else

+	    shared_flag='${wl}-bM:SRE'

+	  fi

+	fi

+      fi

+

+      # It seems that -bexpall does not export symbols beginning with

+      # underscore (_), so it is better to generate a list of symbols to export.

+      always_export_symbols_F77=yes

+      if test "$aix_use_runtimelinking" = yes; then

+	# Warning - without using the other runtime loading flags (-brtl),

+	# -berok will link without error, but may produce a broken library.

+	allow_undefined_flag_F77='-berok'

+       # Determine the default libpath from the value encoded in an empty executable.

+       cat >conftest.$ac_ext <<_ACEOF

+      program main

+

+      end

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_f77_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+

+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`

+# Check for a 64-bit object if we didn't find anything.

+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`; fi

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi

+

+       hardcode_libdir_flag_spec_F77='${wl}-blibpath:$libdir:'"$aix_libpath"

+	archive_expsym_cmds_F77="\$CC"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"

+       else

+	if test "$host_cpu" = ia64; then

+	  hardcode_libdir_flag_spec_F77='${wl}-R $libdir:/usr/lib:/lib'

+	  allow_undefined_flag_F77="-z nodefs"

+	  archive_expsym_cmds_F77="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"

+	else

+	 # Determine the default libpath from the value encoded in an empty executable.

+	 cat >conftest.$ac_ext <<_ACEOF

+      program main

+

+      end

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_f77_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+

+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`

+# Check for a 64-bit object if we didn't find anything.

+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`; fi

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi

+

+	 hardcode_libdir_flag_spec_F77='${wl}-blibpath:$libdir:'"$aix_libpath"

+	  # Warning - without using the other run time loading flags,

+	  # -berok will link without error, but may produce a broken library.

+	  no_undefined_flag_F77=' ${wl}-bernotok'

+	  allow_undefined_flag_F77=' ${wl}-berok'

+	  # Exported symbols can be pulled into shared objects from archives

+	  whole_archive_flag_spec_F77='$convenience'

+	  archive_cmds_need_lc_F77=yes

+	  # This is similar to how AIX traditionally builds its shared libraries.

+	  archive_expsym_cmds_F77="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'

+	fi

+      fi

+      ;;

+

+    amigaos*)

+      archive_cmds_F77='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'

+      hardcode_libdir_flag_spec_F77='-L$libdir'

+      hardcode_minus_L_F77=yes

+      # see comment about different semantics on the GNU ld section

+      ld_shlibs_F77=no

+      ;;

+

+    bsdi[45]*)

+      export_dynamic_flag_spec_F77=-rdynamic

+      ;;

+

+    cygwin* | mingw* | pw32*)

+      # When not using gcc, we currently assume that we are using

+      # Microsoft Visual C++.

+      # hardcode_libdir_flag_spec is actually meaningless, as there is

+      # no search path for DLLs.

+      hardcode_libdir_flag_spec_F77=' '

+      allow_undefined_flag_F77=unsupported

+      # Tell ltmain to make .lib files, not .a files.

+      libext=lib

+      # Tell ltmain to make .dll files, not .so files.

+      shrext_cmds=".dll"

+      # FIXME: Setting linknames here is a bad hack.

+      archive_cmds_F77='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames='

+      # The linker will automatically build a .lib file if we build a DLL.

+      old_archive_From_new_cmds_F77='true'

+      # FIXME: Should let the user specify the lib program.

+      old_archive_cmds_F77='lib /OUT:$oldlib$oldobjs$old_deplibs'

+      fix_srcfile_path_F77='`cygpath -w "$srcfile"`'

+      enable_shared_with_static_runtimes_F77=yes

+      ;;

+

+    darwin* | rhapsody*)

+      case $host_os in

+        rhapsody* | darwin1.[012])

+         allow_undefined_flag_F77='${wl}-undefined ${wl}suppress'

+         ;;

+       *) # Darwin 1.3 on

+         if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then

+           allow_undefined_flag_F77='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'

+         else

+           case ${MACOSX_DEPLOYMENT_TARGET} in

+             10.[012])

+               allow_undefined_flag_F77='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'

+               ;;

+             10.*)

+               allow_undefined_flag_F77='${wl}-undefined ${wl}dynamic_lookup'

+               ;;

+           esac

+         fi

+         ;;

+      esac

+      archive_cmds_need_lc_F77=no

+      hardcode_direct_F77=no

+      hardcode_automatic_F77=yes

+      hardcode_shlibpath_var_F77=unsupported

+      whole_archive_flag_spec_F77=''

+      link_all_deplibs_F77=yes

+    if test "$GCC" = yes ; then

+    	output_verbose_link_cmd='echo'

+        archive_cmds_F77='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'

+      module_cmds_F77='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'

+      # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds

+      archive_expsym_cmds_F77='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+      module_expsym_cmds_F77='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+    else

+      case $cc_basename in

+        xlc*)

+         output_verbose_link_cmd='echo'

+         archive_cmds_F77='$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'

+         module_cmds_F77='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'

+          # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds

+         archive_expsym_cmds_F77='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+          module_expsym_cmds_F77='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+          ;;

+       *)

+         ld_shlibs_F77=no

+          ;;

+      esac

+    fi

+      ;;

+

+    dgux*)

+      archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+      hardcode_libdir_flag_spec_F77='-L$libdir'

+      hardcode_shlibpath_var_F77=no

+      ;;

+

+    freebsd1*)

+      ld_shlibs_F77=no

+      ;;

+

+    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor

+    # support.  Future versions do this automatically, but an explicit c++rt0.o

+    # does not break anything, and helps significantly (at the cost of a little

+    # extra space).

+    freebsd2.2*)

+      archive_cmds_F77='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'

+      hardcode_libdir_flag_spec_F77='-R$libdir'

+      hardcode_direct_F77=yes

+      hardcode_shlibpath_var_F77=no

+      ;;

+

+    # Unfortunately, older versions of FreeBSD 2 do not have this feature.

+    freebsd2*)

+      archive_cmds_F77='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'

+      hardcode_direct_F77=yes

+      hardcode_minus_L_F77=yes

+      hardcode_shlibpath_var_F77=no

+      ;;

+

+    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.

+    freebsd* | dragonfly*)

+      archive_cmds_F77='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'

+      hardcode_libdir_flag_spec_F77='-R$libdir'

+      hardcode_direct_F77=yes

+      hardcode_shlibpath_var_F77=no

+      ;;

+

+    # GNU/kFreeBSD uses gcc -shared to do shared libraries.

+    kfreebsd*-gnu)

+      archive_cmds_F77='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'

+      hardcode_libdir_flag_spec_F77='-R$libdir'

+      hardcode_direct_F77=yes

+      hardcode_shlibpath_var_F77=no

+      link_all_deplibs_F77=no

+      ;;

+

+    hpux9*)

+      if test "$GCC" = yes; then

+	archive_cmds_F77='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

+      else

+	archive_cmds_F77='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

+      fi

+      hardcode_libdir_flag_spec_F77='${wl}+b ${wl}$libdir'

+      hardcode_libdir_separator_F77=:

+      hardcode_direct_F77=yes

+

+      # hardcode_minus_L: Not really in the search PATH,

+      # but as the default location of the library.

+      hardcode_minus_L_F77=yes

+      export_dynamic_flag_spec_F77='${wl}-E'

+      ;;

+

+    hpux10*)

+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then

+	archive_cmds_F77='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

+      else

+	archive_cmds_F77='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'

+      fi

+      if test "$with_gnu_ld" = no; then

+	hardcode_libdir_flag_spec_F77='${wl}+b ${wl}$libdir'

+	hardcode_libdir_separator_F77=:

+

+	hardcode_direct_F77=yes

+	export_dynamic_flag_spec_F77='${wl}-E'

+

+	# hardcode_minus_L: Not really in the search PATH,

+	# but as the default location of the library.

+	hardcode_minus_L_F77=yes

+      fi

+      ;;

+

+    hpux11*)

+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then

+	case $host_cpu in

+	hppa*64*)

+	  archive_cmds_F77='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	ia64*)

+	  archive_cmds_F77='$CC -shared ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	*)

+	  archive_cmds_F77='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	esac

+      else

+	case $host_cpu in

+	hppa*64*)

+	  archive_cmds_F77='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	ia64*)

+	  archive_cmds_F77='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	*)

+	  archive_cmds_F77='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	esac

+      fi

+      if test "$with_gnu_ld" = no; then

+	hardcode_libdir_flag_spec_F77='${wl}+b ${wl}$libdir'

+	hardcode_libdir_separator_F77=:

+

+	case $host_cpu in

+	hppa*64*|ia64*)

+	  hardcode_libdir_flag_spec_ld_F77='+b $libdir'

+	  hardcode_direct_F77=no

+	  hardcode_shlibpath_var_F77=no

+	  ;;

+	*)

+	  hardcode_direct_F77=yes

+	  export_dynamic_flag_spec_F77='${wl}-E'

+

+	  # hardcode_minus_L: Not really in the search PATH,

+	  # but as the default location of the library.

+	  hardcode_minus_L_F77=yes

+	  ;;

+	esac

+      fi

+      ;;

+

+    irix5* | irix6* | nonstopux*)

+      if test "$GCC" = yes; then

+	archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+      else

+	archive_cmds_F77='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+	hardcode_libdir_flag_spec_ld_F77='-rpath $libdir'

+      fi

+      hardcode_libdir_flag_spec_F77='${wl}-rpath ${wl}$libdir'

+      hardcode_libdir_separator_F77=:

+      link_all_deplibs_F77=yes

+      ;;

+

+    netbsd* | netbsdelf*-gnu | knetbsd*-gnu)

+      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

+	archive_cmds_F77='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out

+      else

+	archive_cmds_F77='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF

+      fi

+      hardcode_libdir_flag_spec_F77='-R$libdir'

+      hardcode_direct_F77=yes

+      hardcode_shlibpath_var_F77=no

+      ;;

+

+    newsos6)

+      archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+      hardcode_direct_F77=yes

+      hardcode_libdir_flag_spec_F77='${wl}-rpath ${wl}$libdir'

+      hardcode_libdir_separator_F77=:

+      hardcode_shlibpath_var_F77=no

+      ;;

+

+    openbsd*)

+      hardcode_direct_F77=yes

+      hardcode_shlibpath_var_F77=no

+      if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

+	archive_cmds_F77='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds_F77='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'

+	hardcode_libdir_flag_spec_F77='${wl}-rpath,$libdir'

+	export_dynamic_flag_spec_F77='${wl}-E'

+      else

+       case $host_os in

+	 openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*)

+	   archive_cmds_F77='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'

+	   hardcode_libdir_flag_spec_F77='-R$libdir'

+	   ;;

+	 *)

+	   archive_cmds_F77='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'

+	   hardcode_libdir_flag_spec_F77='${wl}-rpath,$libdir'

+	   ;;

+       esac

+      fi

+      ;;

+

+    os2*)

+      hardcode_libdir_flag_spec_F77='-L$libdir'

+      hardcode_minus_L_F77=yes

+      allow_undefined_flag_F77=unsupported

+      archive_cmds_F77='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'

+      old_archive_From_new_cmds_F77='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'

+      ;;

+

+    osf3*)

+      if test "$GCC" = yes; then

+	allow_undefined_flag_F77=' ${wl}-expect_unresolved ${wl}\*'

+	archive_cmds_F77='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+      else

+	allow_undefined_flag_F77=' -expect_unresolved \*'

+	archive_cmds_F77='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+      fi

+      hardcode_libdir_flag_spec_F77='${wl}-rpath ${wl}$libdir'

+      hardcode_libdir_separator_F77=:

+      ;;

+

+    osf4* | osf5*)	# as osf3* with the addition of -msym flag

+      if test "$GCC" = yes; then

+	allow_undefined_flag_F77=' ${wl}-expect_unresolved ${wl}\*'

+	archive_cmds_F77='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+	hardcode_libdir_flag_spec_F77='${wl}-rpath ${wl}$libdir'

+      else

+	allow_undefined_flag_F77=' -expect_unresolved \*'

+	archive_cmds_F77='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+	archive_expsym_cmds_F77='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~

+	$LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib~$rm $lib.exp'

+

+	# Both c and cxx compiler support -rpath directly

+	hardcode_libdir_flag_spec_F77='-rpath $libdir'

+      fi

+      hardcode_libdir_separator_F77=:

+      ;;

+

+    solaris*)

+      no_undefined_flag_F77=' -z text'

+      if test "$GCC" = yes; then

+	wlarc='${wl}'

+	archive_cmds_F77='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds_F77='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

+	  $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp'

+      else

+	wlarc=''

+	archive_cmds_F77='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'

+	archive_expsym_cmds_F77='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

+  	$LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'

+      fi

+      hardcode_libdir_flag_spec_F77='-R$libdir'

+      hardcode_shlibpath_var_F77=no

+      case $host_os in

+      solaris2.[0-5] | solaris2.[0-5].*) ;;

+      *)

+ 	# The compiler driver will combine linker options so we

+ 	# cannot just pass the convience library names through

+ 	# without $wl, iff we do not link with $LD.

+ 	# Luckily, gcc supports the same syntax we need for Sun Studio.

+ 	# Supported since Solaris 2.6 (maybe 2.5.1?)

+ 	case $wlarc in

+ 	'')

+ 	  whole_archive_flag_spec_F77='-z allextract$convenience -z defaultextract' ;;

+ 	*)

+ 	  whole_archive_flag_spec_F77='${wl}-z ${wl}allextract`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}-z ${wl}defaultextract' ;;

+ 	esac ;;

+      esac

+      link_all_deplibs_F77=yes

+      ;;

+

+    sunos4*)

+      if test "x$host_vendor" = xsequent; then

+	# Use $CC to link under sequent, because it throws in some extra .o

+	# files that make .init and .fini sections work.

+	archive_cmds_F77='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'

+      else

+	archive_cmds_F77='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'

+      fi

+      hardcode_libdir_flag_spec_F77='-L$libdir'

+      hardcode_direct_F77=yes

+      hardcode_minus_L_F77=yes

+      hardcode_shlibpath_var_F77=no

+      ;;

+

+    sysv4)

+      case $host_vendor in

+	sni)

+	  archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+	  hardcode_direct_F77=yes # is this really true???

+	;;

+	siemens)

+	  ## LD is ld it makes a PLAMLIB

+	  ## CC just makes a GrossModule.

+	  archive_cmds_F77='$LD -G -o $lib $libobjs $deplibs $linker_flags'

+	  reload_cmds_F77='$CC -r -o $output$reload_objs'

+	  hardcode_direct_F77=no

+        ;;

+	motorola)

+	  archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+	  hardcode_direct_F77=no #Motorola manual says yes, but my tests say they lie

+	;;

+      esac

+      runpath_var='LD_RUN_PATH'

+      hardcode_shlibpath_var_F77=no

+      ;;

+

+    sysv4.3*)

+      archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+      hardcode_shlibpath_var_F77=no

+      export_dynamic_flag_spec_F77='-Bexport'

+      ;;

+

+    sysv4*MP*)

+      if test -d /usr/nec; then

+	archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+	hardcode_shlibpath_var_F77=no

+	runpath_var=LD_RUN_PATH

+	hardcode_runpath_var=yes

+	ld_shlibs_F77=yes

+      fi

+      ;;

+

+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7*)

+      no_undefined_flag_F77='${wl}-z,text'

+      archive_cmds_need_lc_F77=no

+      hardcode_shlibpath_var_F77=no

+      runpath_var='LD_RUN_PATH'

+

+      if test "$GCC" = yes; then

+	archive_cmds_F77='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds_F77='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+      else

+	archive_cmds_F77='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds_F77='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+      fi

+      ;;

+

+    sysv5* | sco3.2v5* | sco5v6*)

+      # Note: We can NOT use -z defs as we might desire, because we do not

+      # link with -lc, and that would cause any symbols used from libc to

+      # always be unresolved, which means just about no library would

+      # ever link correctly.  If we're not using GNU ld we use -z text

+      # though, which does catch some bad symbols but isn't as heavy-handed

+      # as -z defs.

+      no_undefined_flag_F77='${wl}-z,text'

+      allow_undefined_flag_F77='${wl}-z,nodefs'

+      archive_cmds_need_lc_F77=no

+      hardcode_shlibpath_var_F77=no

+      hardcode_libdir_flag_spec_F77='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'

+      hardcode_libdir_separator_F77=':'

+      link_all_deplibs_F77=yes

+      export_dynamic_flag_spec_F77='${wl}-Bexport'

+      runpath_var='LD_RUN_PATH'

+

+      if test "$GCC" = yes; then

+	archive_cmds_F77='$CC -shared ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds_F77='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+      else

+	archive_cmds_F77='$CC -G ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds_F77='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+      fi

+      ;;

+

+    uts4*)

+      archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+      hardcode_libdir_flag_spec_F77='-L$libdir'

+      hardcode_shlibpath_var_F77=no

+      ;;

+

+    *)

+      ld_shlibs_F77=no

+      ;;

+    esac

+  fi

+

+echo "$as_me:$LINENO: result: $ld_shlibs_F77" >&5

+echo "${ECHO_T}$ld_shlibs_F77" >&6

+test "$ld_shlibs_F77" = no && can_build_shared=no

+

+#

+# Do we need to explicitly link libc?

+#

+case "x$archive_cmds_need_lc_F77" in

+x|xyes)

+  # Assume -lc should be added

+  archive_cmds_need_lc_F77=yes

+

+  if test "$enable_shared" = yes && test "$GCC" = yes; then

+    case $archive_cmds_F77 in

+    *'~'*)

+      # FIXME: we may have to deal with multi-command sequences.

+      ;;

+    '$CC '*)

+      # Test whether the compiler implicitly links with -lc since on some

+      # systems, -lgcc has to come before -lc. If gcc already passes -lc

+      # to ld, don't add -lc before -lgcc.

+      echo "$as_me:$LINENO: checking whether -lc should be explicitly linked in" >&5

+echo $ECHO_N "checking whether -lc should be explicitly linked in... $ECHO_C" >&6

+      $rm conftest*

+      printf "$lt_simple_compile_test_code" > conftest.$ac_ext

+

+      if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } 2>conftest.err; then

+        soname=conftest

+        lib=conftest

+        libobjs=conftest.$ac_objext

+        deplibs=

+        wl=$lt_prog_compiler_wl_F77

+	pic_flag=$lt_prog_compiler_pic_F77

+        compiler_flags=-v

+        linker_flags=-v

+        verstring=

+        output_objdir=.

+        libname=conftest

+        lt_save_allow_undefined_flag=$allow_undefined_flag_F77

+        allow_undefined_flag_F77=

+        if { (eval echo "$as_me:$LINENO: \"$archive_cmds_F77 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\"") >&5

+  (eval $archive_cmds_F77 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }

+        then

+	  archive_cmds_need_lc_F77=no

+        else

+	  archive_cmds_need_lc_F77=yes

+        fi

+        allow_undefined_flag_F77=$lt_save_allow_undefined_flag

+      else

+        cat conftest.err 1>&5

+      fi

+      $rm conftest*

+      echo "$as_me:$LINENO: result: $archive_cmds_need_lc_F77" >&5

+echo "${ECHO_T}$archive_cmds_need_lc_F77" >&6

+      ;;

+    esac

+  fi

+  ;;

+esac

+

+echo "$as_me:$LINENO: checking dynamic linker characteristics" >&5

+echo $ECHO_N "checking dynamic linker characteristics... $ECHO_C" >&6

+library_names_spec=

+libname_spec='lib$name'

+soname_spec=

+shrext_cmds=".so"

+postinstall_cmds=

+postuninstall_cmds=

+finish_cmds=

+finish_eval=

+shlibpath_var=

+shlibpath_overrides_runpath=unknown

+version_type=none

+dynamic_linker="$host_os ld.so"

+sys_lib_dlsearch_path_spec="/lib /usr/lib"

+if test "$GCC" = yes; then

+  sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`

+  if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then

+    # if the path contains ";" then we assume it to be the separator

+    # otherwise default to the standard path separator (i.e. ":") - it is

+    # assumed that no part of a normal pathname contains ";" but that should

+    # okay in the real world where ";" in dirpaths is itself problematic.

+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`

+  else

+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`

+  fi

+else

+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"

+fi

+need_lib_prefix=unknown

+hardcode_into_libs=no

+

+# when you set need_version to no, make sure it does not cause -set_version

+# flags to be left without arguments

+need_version=unknown

+

+case $host_os in

+aix3*)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'

+  shlibpath_var=LIBPATH

+

+  # AIX 3 has no versioning support, so we append a major version to the name.

+  soname_spec='${libname}${release}${shared_ext}$major'

+  ;;

+

+aix4* | aix5*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  hardcode_into_libs=yes

+  if test "$host_cpu" = ia64; then

+    # AIX 5 supports IA64

+    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'

+    shlibpath_var=LD_LIBRARY_PATH

+  else

+    # With GCC up to 2.95.x, collect2 would create an import file

+    # for dependence libraries.  The import file would start with

+    # the line `#! .'.  This would cause the generated library to

+    # depend on `.', always an invalid library.  This was fixed in

+    # development snapshots of GCC prior to 3.0.

+    case $host_os in

+      aix4 | aix4.[01] | aix4.[01].*)

+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'

+	   echo ' yes '

+	   echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then

+	:

+      else

+	can_build_shared=no

+      fi

+      ;;

+    esac

+    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct

+    # soname into executable. Probably we can add versioning support to

+    # collect2, so additional links can be useful in future.

+    if test "$aix_use_runtimelinking" = yes; then

+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so

+      # instead of lib<name>.a to let people know that these are not

+      # typical AIX shared libraries.

+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+    else

+      # We preserve .a as extension for shared libraries through AIX4.2

+      # and later when we are not doing run time linking.

+      library_names_spec='${libname}${release}.a $libname.a'

+      soname_spec='${libname}${release}${shared_ext}$major'

+    fi

+    shlibpath_var=LIBPATH

+  fi

+  ;;

+

+amigaos*)

+  library_names_spec='$libname.ixlibrary $libname.a'

+  # Create ${libname}_ixlibrary.a entries in /sys/libs.

+  finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'

+  ;;

+

+beos*)

+  library_names_spec='${libname}${shared_ext}'

+  dynamic_linker="$host_os ld.so"

+  shlibpath_var=LIBRARY_PATH

+  ;;

+

+bsdi[45]*)

+  version_type=linux

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"

+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"

+  # the default ld.so.conf also contains /usr/contrib/lib and

+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow

+  # libtool to hard-code these into programs

+  ;;

+

+cygwin* | mingw* | pw32*)

+  version_type=windows

+  shrext_cmds=".dll"

+  need_version=no

+  need_lib_prefix=no

+

+  case $GCC,$host_os in

+  yes,cygwin* | yes,mingw* | yes,pw32*)

+    library_names_spec='$libname.dll.a'

+    # DLL is installed to $(libdir)/../bin by postinstall_cmds

+    postinstall_cmds='base_file=`basename \${file}`~

+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~

+      dldir=$destdir/`dirname \$dlpath`~

+      test -d \$dldir || mkdir -p \$dldir~

+      $install_prog $dir/$dlname \$dldir/$dlname~

+      chmod a+x \$dldir/$dlname'

+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~

+      dlpath=$dir/\$dldll~

+       $rm \$dlpath'

+    shlibpath_overrides_runpath=yes

+

+    case $host_os in

+    cygwin*)

+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'

+      soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'

+      sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"

+      ;;

+    mingw*)

+      # MinGW DLLs use traditional 'lib' prefix

+      soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'

+      sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`

+      if echo "$sys_lib_search_path_spec" | grep ';[c-zC-Z]:/' >/dev/null; then

+        # It is most probably a Windows format PATH printed by

+        # mingw gcc, but we are running on Cygwin. Gcc prints its search

+        # path with ; separators, and with drive letters. We can handle the

+        # drive letters (cygwin fileutils understands them), so leave them,

+        # especially as we might pass files found there to a mingw objdump,

+        # which wouldn't understand a cygwinified path. Ahh.

+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`

+      else

+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`

+      fi

+      ;;

+    pw32*)

+      # pw32 DLLs use 'pw' prefix rather than 'lib'

+      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'

+      ;;

+    esac

+    ;;

+

+  *)

+    library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib'

+    ;;

+  esac

+  dynamic_linker='Win32 ld.exe'

+  # FIXME: first we should search . and the directory the executable is in

+  shlibpath_var=PATH

+  ;;

+

+darwin* | rhapsody*)

+  dynamic_linker="$host_os dyld"

+  version_type=darwin

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext'

+  soname_spec='${libname}${release}${major}$shared_ext'

+  shlibpath_overrides_runpath=yes

+  shlibpath_var=DYLD_LIBRARY_PATH

+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'

+  # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same.

+  if test "$GCC" = yes; then

+    sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"`

+  else

+    sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib'

+  fi

+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'

+  ;;

+

+dgux*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  ;;

+

+freebsd1*)

+  dynamic_linker=no

+  ;;

+

+kfreebsd*-gnu)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  dynamic_linker='GNU ld.so'

+  ;;

+

+freebsd* | dragonfly*)

+  # DragonFly does not have aout.  When/if they implement a new

+  # versioning mechanism, adjust this.

+  if test -x /usr/bin/objformat; then

+    objformat=`/usr/bin/objformat`

+  else

+    case $host_os in

+    freebsd[123]*) objformat=aout ;;

+    *) objformat=elf ;;

+    esac

+  fi

+  version_type=freebsd-$objformat

+  case $version_type in

+    freebsd-elf*)

+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'

+      need_version=no

+      need_lib_prefix=no

+      ;;

+    freebsd-*)

+      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'

+      need_version=yes

+      ;;

+  esac

+  shlibpath_var=LD_LIBRARY_PATH

+  case $host_os in

+  freebsd2*)

+    shlibpath_overrides_runpath=yes

+    ;;

+  freebsd3.[01]* | freebsdelf3.[01]*)

+    shlibpath_overrides_runpath=yes

+    hardcode_into_libs=yes

+    ;;

+  freebsd3.[2-9]* | freebsdelf3.[2-9]* | \

+  freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)

+    shlibpath_overrides_runpath=no

+    hardcode_into_libs=yes

+    ;;

+  freebsd*) # from 4.6 on

+    shlibpath_overrides_runpath=yes

+    hardcode_into_libs=yes

+    ;;

+  esac

+  ;;

+

+gnu*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  hardcode_into_libs=yes

+  ;;

+

+hpux9* | hpux10* | hpux11*)

+  # Give a soname corresponding to the major version so that dld.sl refuses to

+  # link against other versions.

+  version_type=sunos

+  need_lib_prefix=no

+  need_version=no

+  case $host_cpu in

+  ia64*)

+    shrext_cmds='.so'

+    hardcode_into_libs=yes

+    dynamic_linker="$host_os dld.so"

+    shlibpath_var=LD_LIBRARY_PATH

+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+    soname_spec='${libname}${release}${shared_ext}$major'

+    if test "X$HPUX_IA64_MODE" = X32; then

+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"

+    else

+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"

+    fi

+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec

+    ;;

+   hppa*64*)

+     shrext_cmds='.sl'

+     hardcode_into_libs=yes

+     dynamic_linker="$host_os dld.sl"

+     shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH

+     shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.

+     library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+     soname_spec='${libname}${release}${shared_ext}$major'

+     sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"

+     sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec

+     ;;

+   *)

+    shrext_cmds='.sl'

+    dynamic_linker="$host_os dld.sl"

+    shlibpath_var=SHLIB_PATH

+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+    soname_spec='${libname}${release}${shared_ext}$major'

+    ;;

+  esac

+  # HP-UX runs *really* slowly unless shared libraries are mode 555.

+  postinstall_cmds='chmod 555 $lib'

+  ;;

+

+interix3*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  ;;

+

+irix5* | irix6* | nonstopux*)

+  case $host_os in

+    nonstopux*) version_type=nonstopux ;;

+    *)

+	if test "$lt_cv_prog_gnu_ld" = yes; then

+		version_type=linux

+	else

+		version_type=irix

+	fi ;;

+  esac

+  need_lib_prefix=no

+  need_version=no

+  soname_spec='${libname}${release}${shared_ext}$major'

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'

+  case $host_os in

+  irix5* | nonstopux*)

+    libsuff= shlibsuff=

+    ;;

+  *)

+    case $LD in # libtool.m4 will add one of these switches to LD

+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")

+      libsuff= shlibsuff= libmagic=32-bit;;

+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")

+      libsuff=32 shlibsuff=N32 libmagic=N32;;

+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")

+      libsuff=64 shlibsuff=64 libmagic=64-bit;;

+    *) libsuff= shlibsuff= libmagic=never-match;;

+    esac

+    ;;

+  esac

+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH

+  shlibpath_overrides_runpath=no

+  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"

+  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"

+  hardcode_into_libs=yes

+  ;;

+

+# No shared lib support for Linux oldld, aout, or coff.

+linux*oldld* | linux*aout* | linux*coff*)

+  dynamic_linker=no

+  ;;

+

+# This must be Linux ELF.

+linux*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  # This implies no fast_install, which is unacceptable.

+  # Some rework will be needed to allow for fast_install

+  # before this can be enabled.

+  hardcode_into_libs=yes

+

+  # Append ld.so.conf contents to the search path

+  if test -f /etc/ld.so.conf; then

+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;/^$/d' | tr '\n' ' '`

+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"

+  fi

+

+  # We used to test for /lib/ld.so.1 and disable shared libraries on

+  # powerpc, because MkLinux only supported shared libraries with the

+  # GNU dynamic linker.  Since this was broken with cross compilers,

+  # most powerpc-linux boxes support dynamic linking these days and

+  # people can always --disable-shared, the test was removed, and we

+  # assume the GNU/Linux dynamic linker is in use.

+  dynamic_linker='GNU/Linux ld.so'

+  ;;

+

+netbsdelf*-gnu)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  dynamic_linker='NetBSD ld.elf_so'

+  ;;

+

+knetbsd*-gnu)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  dynamic_linker='GNU ld.so'

+  ;;

+

+netbsd*)

+  version_type=sunos

+  need_lib_prefix=no

+  need_version=no

+  if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'

+    dynamic_linker='NetBSD (a.out) ld.so'

+  else

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+    soname_spec='${libname}${release}${shared_ext}$major'

+    dynamic_linker='NetBSD ld.elf_so'

+  fi

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  hardcode_into_libs=yes

+  ;;

+

+newsos6)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  ;;

+

+nto-qnx*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  ;;

+

+openbsd*)

+  version_type=sunos

+  sys_lib_dlsearch_path_spec="/usr/lib"

+  need_lib_prefix=no

+  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.

+  case $host_os in

+    openbsd3.3 | openbsd3.3.*) need_version=yes ;;

+    *)                         need_version=no  ;;

+  esac

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

+    case $host_os in

+      openbsd2.[89] | openbsd2.[89].*)

+	shlibpath_overrides_runpath=no

+	;;

+      *)

+	shlibpath_overrides_runpath=yes

+	;;

+      esac

+  else

+    shlibpath_overrides_runpath=yes

+  fi

+  ;;

+

+os2*)

+  libname_spec='$name'

+  shrext_cmds=".dll"

+  need_lib_prefix=no

+  library_names_spec='$libname${shared_ext} $libname.a'

+  dynamic_linker='OS/2 ld.exe'

+  shlibpath_var=LIBPATH

+  ;;

+

+osf3* | osf4* | osf5*)

+  version_type=osf

+  need_lib_prefix=no

+  need_version=no

+  soname_spec='${libname}${release}${shared_ext}$major'

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  shlibpath_var=LD_LIBRARY_PATH

+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"

+  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"

+  ;;

+

+solaris*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  hardcode_into_libs=yes

+  # ldd complains unless libraries are executable

+  postinstall_cmds='chmod +x $lib'

+  ;;

+

+sunos4*)

+  version_type=sunos

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  if test "$with_gnu_ld" = yes; then

+    need_lib_prefix=no

+  fi

+  need_version=yes

+  ;;

+

+sysv4 | sysv4.3*)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  case $host_vendor in

+    sni)

+      shlibpath_overrides_runpath=no

+      need_lib_prefix=no

+      export_dynamic_flag_spec='${wl}-Blargedynsym'

+      runpath_var=LD_RUN_PATH

+      ;;

+    siemens)

+      need_lib_prefix=no

+      ;;

+    motorola)

+      need_lib_prefix=no

+      need_version=no

+      shlibpath_overrides_runpath=no

+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'

+      ;;

+  esac

+  ;;

+

+sysv4*MP*)

+  if test -d /usr/nec ;then

+    version_type=linux

+    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'

+    soname_spec='$libname${shared_ext}.$major'

+    shlibpath_var=LD_LIBRARY_PATH

+  fi

+  ;;

+

+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)

+  version_type=freebsd-elf

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  hardcode_into_libs=yes

+  if test "$with_gnu_ld" = yes; then

+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'

+    shlibpath_overrides_runpath=no

+  else

+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'

+    shlibpath_overrides_runpath=yes

+    case $host_os in

+      sco3.2v5*)

+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"

+	;;

+    esac

+  fi

+  sys_lib_dlsearch_path_spec='/usr/lib'

+  ;;

+

+uts4*)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  ;;

+

+*)

+  dynamic_linker=no

+  ;;

+esac

+echo "$as_me:$LINENO: result: $dynamic_linker" >&5

+echo "${ECHO_T}$dynamic_linker" >&6

+test "$dynamic_linker" = no && can_build_shared=no

+

+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"

+if test "$GCC" = yes; then

+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"

+fi

+

+echo "$as_me:$LINENO: checking how to hardcode library paths into programs" >&5

+echo $ECHO_N "checking how to hardcode library paths into programs... $ECHO_C" >&6

+hardcode_action_F77=

+if test -n "$hardcode_libdir_flag_spec_F77" || \

+   test -n "$runpath_var_F77" || \

+   test "X$hardcode_automatic_F77" = "Xyes" ; then

+

+  # We can hardcode non-existant directories.

+  if test "$hardcode_direct_F77" != no &&

+     # If the only mechanism to avoid hardcoding is shlibpath_var, we

+     # have to relink, otherwise we might link with an installed library

+     # when we should be linking with a yet-to-be-installed one

+     ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, F77)" != no &&

+     test "$hardcode_minus_L_F77" != no; then

+    # Linking always hardcodes the temporary library directory.

+    hardcode_action_F77=relink

+  else

+    # We can link without hardcoding, and we can hardcode nonexisting dirs.

+    hardcode_action_F77=immediate

+  fi

+else

+  # We cannot hardcode anything, or else we can only hardcode existing

+  # directories.

+  hardcode_action_F77=unsupported

+fi

+echo "$as_me:$LINENO: result: $hardcode_action_F77" >&5

+echo "${ECHO_T}$hardcode_action_F77" >&6

+

+if test "$hardcode_action_F77" = relink; then

+  # Fast installation is not supported

+  enable_fast_install=no

+elif test "$shlibpath_overrides_runpath" = yes ||

+     test "$enable_shared" = no; then

+  # Fast installation is not necessary

+  enable_fast_install=needless

+fi

+

+

+# The else clause should only fire when bootstrapping the

+# libtool distribution, otherwise you forgot to ship ltmain.sh

+# with your package, and you will get complaints that there are

+# no rules to generate ltmain.sh.

+if test -f "$ltmain"; then

+  # See if we are running on zsh, and set the options which allow our commands through

+  # without removal of \ escapes.

+  if test -n "${ZSH_VERSION+set}" ; then

+    setopt NO_GLOB_SUBST

+  fi

+  # Now quote all the things that may contain metacharacters while being

+  # careful not to overquote the AC_SUBSTed values.  We take copies of the

+  # variables and quote the copies for generation of the libtool script.

+  for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC LTCFLAGS NM \

+    SED SHELL STRIP \

+    libname_spec library_names_spec soname_spec extract_expsyms_cmds \

+    old_striplib striplib file_magic_cmd finish_cmds finish_eval \

+    deplibs_check_method reload_flag reload_cmds need_locks \

+    lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \

+    lt_cv_sys_global_symbol_to_c_name_address \

+    sys_lib_search_path_spec sys_lib_dlsearch_path_spec \

+    old_postinstall_cmds old_postuninstall_cmds \

+    compiler_F77 \

+    CC_F77 \

+    LD_F77 \

+    lt_prog_compiler_wl_F77 \

+    lt_prog_compiler_pic_F77 \

+    lt_prog_compiler_static_F77 \

+    lt_prog_compiler_no_builtin_flag_F77 \

+    export_dynamic_flag_spec_F77 \

+    thread_safe_flag_spec_F77 \

+    whole_archive_flag_spec_F77 \

+    enable_shared_with_static_runtimes_F77 \

+    old_archive_cmds_F77 \

+    old_archive_from_new_cmds_F77 \

+    predep_objects_F77 \

+    postdep_objects_F77 \

+    predeps_F77 \

+    postdeps_F77 \

+    compiler_lib_search_path_F77 \

+    archive_cmds_F77 \

+    archive_expsym_cmds_F77 \

+    postinstall_cmds_F77 \

+    postuninstall_cmds_F77 \

+    old_archive_from_expsyms_cmds_F77 \

+    allow_undefined_flag_F77 \

+    no_undefined_flag_F77 \

+    export_symbols_cmds_F77 \

+    hardcode_libdir_flag_spec_F77 \

+    hardcode_libdir_flag_spec_ld_F77 \

+    hardcode_libdir_separator_F77 \

+    hardcode_automatic_F77 \

+    module_cmds_F77 \

+    module_expsym_cmds_F77 \

+    lt_cv_prog_compiler_c_o_F77 \

+    exclude_expsyms_F77 \

+    include_expsyms_F77; do

+

+    case $var in

+    old_archive_cmds_F77 | \

+    old_archive_from_new_cmds_F77 | \

+    archive_cmds_F77 | \

+    archive_expsym_cmds_F77 | \

+    module_cmds_F77 | \

+    module_expsym_cmds_F77 | \

+    old_archive_from_expsyms_cmds_F77 | \

+    export_symbols_cmds_F77 | \

+    extract_expsyms_cmds | reload_cmds | finish_cmds | \

+    postinstall_cmds | postuninstall_cmds | \

+    old_postinstall_cmds | old_postuninstall_cmds | \

+    sys_lib_search_path_spec | sys_lib_dlsearch_path_spec)

+      # Double-quote double-evaled strings.

+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\""

+      ;;

+    *)

+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\""

+      ;;

+    esac

+  done

+

+  case $lt_echo in

+  *'\$0 --fallback-echo"')

+    lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'`

+    ;;

+  esac

+

+cfgfile="$ofile"

+

+  cat <<__EOF__ >> "$cfgfile"

+# ### BEGIN LIBTOOL TAG CONFIG: $tagname

+

+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:

+

+# Shell to use when invoking shell scripts.

+SHELL=$lt_SHELL

+

+# Whether or not to build shared libraries.

+build_libtool_libs=$enable_shared

+

+# Whether or not to build static libraries.

+build_old_libs=$enable_static

+

+# Whether or not to add -lc for building shared libraries.

+build_libtool_need_lc=$archive_cmds_need_lc_F77

+

+# Whether or not to disallow shared libs when runtime libs are static

+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_F77

+

+# Whether or not to optimize for fast installation.

+fast_install=$enable_fast_install

+

+# The host system.

+host_alias=$host_alias

+host=$host

+host_os=$host_os

+

+# The build system.

+build_alias=$build_alias

+build=$build

+build_os=$build_os

+

+# An echo program that does not interpret backslashes.

+echo=$lt_echo

+

+# The archiver.

+AR=$lt_AR

+AR_FLAGS=$lt_AR_FLAGS

+

+# A C compiler.

+LTCC=$lt_LTCC

+

+# LTCC compiler flags.

+LTCFLAGS=$lt_LTCFLAGS

+

+# A language-specific compiler.

+CC=$lt_compiler_F77

+

+# Is the compiler the GNU C compiler?

+with_gcc=$GCC_F77

+

+# An ERE matcher.

+EGREP=$lt_EGREP

+

+# The linker used to build libraries.

+LD=$lt_LD_F77

+

+# Whether we need hard or soft links.

+LN_S=$lt_LN_S

+

+# A BSD-compatible nm program.

+NM=$lt_NM

+

+# A symbol stripping program

+STRIP=$lt_STRIP

+

+# Used to examine libraries when file_magic_cmd begins "file"

+MAGIC_CMD=$MAGIC_CMD

+

+# Used on cygwin: DLL creation program.

+DLLTOOL="$DLLTOOL"

+

+# Used on cygwin: object dumper.

+OBJDUMP="$OBJDUMP"

+

+# Used on cygwin: assembler.

+AS="$AS"

+

+# The name of the directory that contains temporary libtool files.

+objdir=$objdir

+

+# How to create reloadable object files.

+reload_flag=$lt_reload_flag

+reload_cmds=$lt_reload_cmds

+

+# How to pass a linker flag through the compiler.

+wl=$lt_lt_prog_compiler_wl_F77

+

+# Object file suffix (normally "o").

+objext="$ac_objext"

+

+# Old archive suffix (normally "a").

+libext="$libext"

+

+# Shared library suffix (normally ".so").

+shrext_cmds='$shrext_cmds'

+

+# Executable file suffix (normally "").

+exeext="$exeext"

+

+# Additional compiler flags for building library objects.

+pic_flag=$lt_lt_prog_compiler_pic_F77

+pic_mode=$pic_mode

+

+# What is the maximum length of a command?

+max_cmd_len=$lt_cv_sys_max_cmd_len

+

+# Does compiler simultaneously support -c and -o options?

+compiler_c_o=$lt_lt_cv_prog_compiler_c_o_F77

+

+# Must we lock files when doing compilation?

+need_locks=$lt_need_locks

+

+# Do we need the lib prefix for modules?

+need_lib_prefix=$need_lib_prefix

+

+# Do we need a version for libraries?

+need_version=$need_version

+

+# Whether dlopen is supported.

+dlopen_support=$enable_dlopen

+

+# Whether dlopen of programs is supported.

+dlopen_self=$enable_dlopen_self

+

+# Whether dlopen of statically linked programs is supported.

+dlopen_self_static=$enable_dlopen_self_static

+

+# Compiler flag to prevent dynamic linking.

+link_static_flag=$lt_lt_prog_compiler_static_F77

+

+# Compiler flag to turn off builtin functions.

+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_F77

+

+# Compiler flag to allow reflexive dlopens.

+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_F77

+

+# Compiler flag to generate shared objects directly from archives.

+whole_archive_flag_spec=$lt_whole_archive_flag_spec_F77

+

+# Compiler flag to generate thread-safe objects.

+thread_safe_flag_spec=$lt_thread_safe_flag_spec_F77

+

+# Library versioning type.

+version_type=$version_type

+

+# Format of library name prefix.

+libname_spec=$lt_libname_spec

+

+# List of archive names.  First name is the real one, the rest are links.

+# The last name is the one that the linker finds with -lNAME.

+library_names_spec=$lt_library_names_spec

+

+# The coded name of the library, if different from the real name.

+soname_spec=$lt_soname_spec

+

+# Commands used to build and install an old-style archive.

+RANLIB=$lt_RANLIB

+old_archive_cmds=$lt_old_archive_cmds_F77

+old_postinstall_cmds=$lt_old_postinstall_cmds

+old_postuninstall_cmds=$lt_old_postuninstall_cmds

+

+# Create an old-style archive from a shared archive.

+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_F77

+

+# Create a temporary old-style archive to link instead of a shared archive.

+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_F77

+

+# Commands used to build and install a shared archive.

+archive_cmds=$lt_archive_cmds_F77

+archive_expsym_cmds=$lt_archive_expsym_cmds_F77

+postinstall_cmds=$lt_postinstall_cmds

+postuninstall_cmds=$lt_postuninstall_cmds

+

+# Commands used to build a loadable module (assumed same as above if empty)

+module_cmds=$lt_module_cmds_F77

+module_expsym_cmds=$lt_module_expsym_cmds_F77

+

+# Commands to strip libraries.

+old_striplib=$lt_old_striplib

+striplib=$lt_striplib

+

+# Dependencies to place before the objects being linked to create a

+# shared library.

+predep_objects=$lt_predep_objects_F77

+

+# Dependencies to place after the objects being linked to create a

+# shared library.

+postdep_objects=$lt_postdep_objects_F77

+

+# Dependencies to place before the objects being linked to create a

+# shared library.

+predeps=$lt_predeps_F77

+

+# Dependencies to place after the objects being linked to create a

+# shared library.

+postdeps=$lt_postdeps_F77

+

+# The library search path used internally by the compiler when linking

+# a shared library.

+compiler_lib_search_path=$lt_compiler_lib_search_path_F77

+

+# Method to check whether dependent libraries are shared objects.

+deplibs_check_method=$lt_deplibs_check_method

+

+# Command to use when deplibs_check_method == file_magic.

+file_magic_cmd=$lt_file_magic_cmd

+

+# Flag that allows shared libraries with undefined symbols to be built.

+allow_undefined_flag=$lt_allow_undefined_flag_F77

+

+# Flag that forces no undefined symbols.

+no_undefined_flag=$lt_no_undefined_flag_F77

+

+# Commands used to finish a libtool library installation in a directory.

+finish_cmds=$lt_finish_cmds

+

+# Same as above, but a single script fragment to be evaled but not shown.

+finish_eval=$lt_finish_eval

+

+# Take the output of nm and produce a listing of raw symbols and C names.

+global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe

+

+# Transform the output of nm in a proper C declaration

+global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl

+

+# Transform the output of nm in a C name address pair

+global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address

+

+# This is the shared library runtime path variable.

+runpath_var=$runpath_var

+

+# This is the shared library path variable.

+shlibpath_var=$shlibpath_var

+

+# Is shlibpath searched before the hard-coded library search path?

+shlibpath_overrides_runpath=$shlibpath_overrides_runpath

+

+# How to hardcode a shared library path into an executable.

+hardcode_action=$hardcode_action_F77

+

+# Whether we should hardcode library paths into libraries.

+hardcode_into_libs=$hardcode_into_libs

+

+# Flag to hardcode \$libdir into a binary during linking.

+# This must work even if \$libdir does not exist.

+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_F77

+

+# If ld is used when linking, flag to hardcode \$libdir into

+# a binary during linking. This must work even if \$libdir does

+# not exist.

+hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld_F77

+

+# Whether we need a single -rpath flag with a separated argument.

+hardcode_libdir_separator=$lt_hardcode_libdir_separator_F77

+

+# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the

+# resulting binary.

+hardcode_direct=$hardcode_direct_F77

+

+# Set to yes if using the -LDIR flag during linking hardcodes DIR into the

+# resulting binary.

+hardcode_minus_L=$hardcode_minus_L_F77

+

+# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into

+# the resulting binary.

+hardcode_shlibpath_var=$hardcode_shlibpath_var_F77

+

+# Set to yes if building a shared library automatically hardcodes DIR into the library

+# and all subsequent libraries and executables linked against it.

+hardcode_automatic=$hardcode_automatic_F77

+

+# Variables whose values should be saved in libtool wrapper scripts and

+# restored at relink time.

+variables_saved_for_relink="$variables_saved_for_relink"

+

+# Whether libtool must link a program against all its dependency libraries.

+link_all_deplibs=$link_all_deplibs_F77

+

+# Compile-time system search path for libraries

+sys_lib_search_path_spec=$lt_sys_lib_search_path_spec

+

+# Run-time system search path for libraries

+sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec

+

+# Fix the shell variable \$srcfile for the compiler.

+fix_srcfile_path="$fix_srcfile_path_F77"

+

+# Set to yes if exported symbols are required.

+always_export_symbols=$always_export_symbols_F77

+

+# The commands to list exported symbols.

+export_symbols_cmds=$lt_export_symbols_cmds_F77

+

+# The commands to extract the exported symbol list from a shared archive.

+extract_expsyms_cmds=$lt_extract_expsyms_cmds

+

+# Symbols that should not be listed in the preloaded symbols.

+exclude_expsyms=$lt_exclude_expsyms_F77

+

+# Symbols that must always be exported.

+include_expsyms=$lt_include_expsyms_F77

+

+# ### END LIBTOOL TAG CONFIG: $tagname

+

+__EOF__

+

+

+else

+  # If there is no Makefile yet, we rely on a make rule to execute

+  # `config.status --recheck' to rerun these tests and create the

+  # libtool script then.

+  ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'`

+  if test -f "$ltmain_in"; then

+    test -f Makefile && make "$ltmain"

+  fi

+fi

+

+

+ac_ext=c

+ac_cpp='$CPP $CPPFLAGS'

+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_c_compiler_gnu

+

+CC="$lt_save_CC"

+

+	else

+	  tagname=""

+	fi

+	;;

+

+      GCJ)

+	if test -n "$GCJ" && test "X$GCJ" != "Xno"; then

+

+

+

+# Source file extension for Java test sources.

+ac_ext=java

+

+# Object file extension for compiled Java test sources.

+objext=o

+objext_GCJ=$objext

+

+# Code to be used in simple compile tests

+lt_simple_compile_test_code="class foo {}\n"

+

+# Code to be used in simple link tests

+lt_simple_link_test_code='public class conftest { public static void main(String[] argv) {}; }\n'

+

+# ltmain only uses $CC for tagged configurations so make sure $CC is set.

+

+# If no C compiler was specified, use CC.

+LTCC=${LTCC-"$CC"}

+

+# If no C compiler flags were specified, use CFLAGS.

+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}

+

+# Allow CC to be a program name with arguments.

+compiler=$CC

+

+

+# save warnings/boilerplate of simple test code

+ac_outfile=conftest.$ac_objext

+printf "$lt_simple_compile_test_code" >conftest.$ac_ext

+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err

+_lt_compiler_boilerplate=`cat conftest.err`

+$rm conftest*

+

+ac_outfile=conftest.$ac_objext

+printf "$lt_simple_link_test_code" >conftest.$ac_ext

+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err

+_lt_linker_boilerplate=`cat conftest.err`

+$rm conftest*

+

+

+# Allow CC to be a program name with arguments.

+lt_save_CC="$CC"

+CC=${GCJ-"gcj"}

+compiler=$CC

+compiler_GCJ=$CC

+for cc_temp in $compiler""; do

+  case $cc_temp in

+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;

+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;

+    \-*) ;;

+    *) break;;

+  esac

+done

+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`

+

+

+# GCJ did not exist at the time GCC didn't implicitly link libc in.

+archive_cmds_need_lc_GCJ=no

+

+old_archive_cmds_GCJ=$old_archive_cmds

+

+

+lt_prog_compiler_no_builtin_flag_GCJ=

+

+if test "$GCC" = yes; then

+  lt_prog_compiler_no_builtin_flag_GCJ=' -fno-builtin'

+

+

+echo "$as_me:$LINENO: checking if $compiler supports -fno-rtti -fno-exceptions" >&5

+echo $ECHO_N "checking if $compiler supports -fno-rtti -fno-exceptions... $ECHO_C" >&6

+if test "${lt_cv_prog_compiler_rtti_exceptions+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  lt_cv_prog_compiler_rtti_exceptions=no

+  ac_outfile=conftest.$ac_objext

+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext

+   lt_compiler_flag="-fno-rtti -fno-exceptions"

+   # Insert the option either (1) after the last *FLAGS variable, or

+   # (2) before a word containing "conftest.", or (3) at the end.

+   # Note that $ac_compile itself does not contain backslashes and begins

+   # with a dollar sign (not a hyphen), so the echo should work correctly.

+   # The option is referenced via a variable to avoid confusing sed.

+   lt_compile=`echo "$ac_compile" | $SED \

+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \

+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \

+   -e 's:$: $lt_compiler_flag:'`

+   (eval echo "\"\$as_me:15522: $lt_compile\"" >&5)

+   (eval "$lt_compile" 2>conftest.err)

+   ac_status=$?

+   cat conftest.err >&5

+   echo "$as_me:15526: \$? = $ac_status" >&5

+   if (exit $ac_status) && test -s "$ac_outfile"; then

+     # The compiler can only warn and ignore the option if not recognized

+     # So say no if there are warnings other than the usual output.

+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp

+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then

+       lt_cv_prog_compiler_rtti_exceptions=yes

+     fi

+   fi

+   $rm conftest*

+

+fi

+echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_rtti_exceptions" >&5

+echo "${ECHO_T}$lt_cv_prog_compiler_rtti_exceptions" >&6

+

+if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then

+    lt_prog_compiler_no_builtin_flag_GCJ="$lt_prog_compiler_no_builtin_flag_GCJ -fno-rtti -fno-exceptions"

+else

+    :

+fi

+

+fi

+

+lt_prog_compiler_wl_GCJ=

+lt_prog_compiler_pic_GCJ=

+lt_prog_compiler_static_GCJ=

+

+echo "$as_me:$LINENO: checking for $compiler option to produce PIC" >&5

+echo $ECHO_N "checking for $compiler option to produce PIC... $ECHO_C" >&6

+

+  if test "$GCC" = yes; then

+    lt_prog_compiler_wl_GCJ='-Wl,'

+    lt_prog_compiler_static_GCJ='-static'

+

+    case $host_os in

+      aix*)

+      # All AIX code is PIC.

+      if test "$host_cpu" = ia64; then

+	# AIX 5 now supports IA64 processor

+	lt_prog_compiler_static_GCJ='-Bstatic'

+      fi

+      ;;

+

+    amigaos*)

+      # FIXME: we need at least 68020 code to build shared libraries, but

+      # adding the `-m68020' flag to GCC prevents building anything better,

+      # like `-m68040'.

+      lt_prog_compiler_pic_GCJ='-m68020 -resident32 -malways-restore-a4'

+      ;;

+

+    beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)

+      # PIC is the default for these OSes.

+      ;;

+

+    mingw* | pw32* | os2*)

+      # This hack is so that the source file can tell whether it is being

+      # built for inclusion in a dll (and should export symbols for example).

+      lt_prog_compiler_pic_GCJ='-DDLL_EXPORT'

+      ;;

+

+    darwin* | rhapsody*)

+      # PIC is the default on this platform

+      # Common symbols not allowed in MH_DYLIB files

+      lt_prog_compiler_pic_GCJ='-fno-common'

+      ;;

+

+    interix3*)

+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.

+      # Instead, we relocate shared libraries at runtime.

+      ;;

+

+    msdosdjgpp*)

+      # Just because we use GCC doesn't mean we suddenly get shared libraries

+      # on systems that don't support them.

+      lt_prog_compiler_can_build_shared_GCJ=no

+      enable_shared=no

+      ;;

+

+    sysv4*MP*)

+      if test -d /usr/nec; then

+	lt_prog_compiler_pic_GCJ=-Kconform_pic

+      fi

+      ;;

+

+    hpux*)

+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but

+      # not for PA HP-UX.

+      case $host_cpu in

+      hppa*64*|ia64*)

+	# +Z the default

+	;;

+      *)

+	lt_prog_compiler_pic_GCJ='-fPIC'

+	;;

+      esac

+      ;;

+

+    *)

+      lt_prog_compiler_pic_GCJ='-fPIC'

+      ;;

+    esac

+  else

+    # PORTME Check for flag to pass linker flags through the system compiler.

+    case $host_os in

+    aix*)

+      lt_prog_compiler_wl_GCJ='-Wl,'

+      if test "$host_cpu" = ia64; then

+	# AIX 5 now supports IA64 processor

+	lt_prog_compiler_static_GCJ='-Bstatic'

+      else

+	lt_prog_compiler_static_GCJ='-bnso -bI:/lib/syscalls.exp'

+      fi

+      ;;

+      darwin*)

+        # PIC is the default on this platform

+        # Common symbols not allowed in MH_DYLIB files

+       case $cc_basename in

+         xlc*)

+         lt_prog_compiler_pic_GCJ='-qnocommon'

+         lt_prog_compiler_wl_GCJ='-Wl,'

+         ;;

+       esac

+       ;;

+

+    mingw* | pw32* | os2*)

+      # This hack is so that the source file can tell whether it is being

+      # built for inclusion in a dll (and should export symbols for example).

+      lt_prog_compiler_pic_GCJ='-DDLL_EXPORT'

+      ;;

+

+    hpux9* | hpux10* | hpux11*)

+      lt_prog_compiler_wl_GCJ='-Wl,'

+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but

+      # not for PA HP-UX.

+      case $host_cpu in

+      hppa*64*|ia64*)

+	# +Z the default

+	;;

+      *)

+	lt_prog_compiler_pic_GCJ='+Z'

+	;;

+      esac

+      # Is there a better lt_prog_compiler_static that works with the bundled CC?

+      lt_prog_compiler_static_GCJ='${wl}-a ${wl}archive'

+      ;;

+

+    irix5* | irix6* | nonstopux*)

+      lt_prog_compiler_wl_GCJ='-Wl,'

+      # PIC (with -KPIC) is the default.

+      lt_prog_compiler_static_GCJ='-non_shared'

+      ;;

+

+    newsos6)

+      lt_prog_compiler_pic_GCJ='-KPIC'

+      lt_prog_compiler_static_GCJ='-Bstatic'

+      ;;

+

+    linux*)

+      case $cc_basename in

+      icc* | ecc*)

+	lt_prog_compiler_wl_GCJ='-Wl,'

+	lt_prog_compiler_pic_GCJ='-KPIC'

+	lt_prog_compiler_static_GCJ='-static'

+        ;;

+      pgcc* | pgf77* | pgf90* | pgf95*)

+        # Portland Group compilers (*not* the Pentium gcc compiler,

+	# which looks to be a dead project)

+	lt_prog_compiler_wl_GCJ='-Wl,'

+	lt_prog_compiler_pic_GCJ='-fpic'

+	lt_prog_compiler_static_GCJ='-Bstatic'

+        ;;

+      ccc*)

+        lt_prog_compiler_wl_GCJ='-Wl,'

+        # All Alpha code is PIC.

+        lt_prog_compiler_static_GCJ='-non_shared'

+        ;;

+      esac

+      ;;

+

+    osf3* | osf4* | osf5*)

+      lt_prog_compiler_wl_GCJ='-Wl,'

+      # All OSF/1 code is PIC.

+      lt_prog_compiler_static_GCJ='-non_shared'

+      ;;

+

+    solaris*)

+      lt_prog_compiler_pic_GCJ='-KPIC'

+      lt_prog_compiler_static_GCJ='-Bstatic'

+      case $cc_basename in

+      f77* | f90* | f95*)

+	lt_prog_compiler_wl_GCJ='-Qoption ld ';;

+      *)

+	lt_prog_compiler_wl_GCJ='-Wl,';;

+      esac

+      ;;

+

+    sunos4*)

+      lt_prog_compiler_wl_GCJ='-Qoption ld '

+      lt_prog_compiler_pic_GCJ='-PIC'

+      lt_prog_compiler_static_GCJ='-Bstatic'

+      ;;

+

+    sysv4 | sysv4.2uw2* | sysv4.3*)

+      lt_prog_compiler_wl_GCJ='-Wl,'

+      lt_prog_compiler_pic_GCJ='-KPIC'

+      lt_prog_compiler_static_GCJ='-Bstatic'

+      ;;

+

+    sysv4*MP*)

+      if test -d /usr/nec ;then

+	lt_prog_compiler_pic_GCJ='-Kconform_pic'

+	lt_prog_compiler_static_GCJ='-Bstatic'

+      fi

+      ;;

+

+    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)

+      lt_prog_compiler_wl_GCJ='-Wl,'

+      lt_prog_compiler_pic_GCJ='-KPIC'

+      lt_prog_compiler_static_GCJ='-Bstatic'

+      ;;

+

+    unicos*)

+      lt_prog_compiler_wl_GCJ='-Wl,'

+      lt_prog_compiler_can_build_shared_GCJ=no

+      ;;

+

+    uts4*)

+      lt_prog_compiler_pic_GCJ='-pic'

+      lt_prog_compiler_static_GCJ='-Bstatic'

+      ;;

+

+    *)

+      lt_prog_compiler_can_build_shared_GCJ=no

+      ;;

+    esac

+  fi

+

+echo "$as_me:$LINENO: result: $lt_prog_compiler_pic_GCJ" >&5

+echo "${ECHO_T}$lt_prog_compiler_pic_GCJ" >&6

+

+#

+# Check to make sure the PIC flag actually works.

+#

+if test -n "$lt_prog_compiler_pic_GCJ"; then

+

+echo "$as_me:$LINENO: checking if $compiler PIC flag $lt_prog_compiler_pic_GCJ works" >&5

+echo $ECHO_N "checking if $compiler PIC flag $lt_prog_compiler_pic_GCJ works... $ECHO_C" >&6

+if test "${lt_prog_compiler_pic_works_GCJ+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  lt_prog_compiler_pic_works_GCJ=no

+  ac_outfile=conftest.$ac_objext

+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext

+   lt_compiler_flag="$lt_prog_compiler_pic_GCJ"

+   # Insert the option either (1) after the last *FLAGS variable, or

+   # (2) before a word containing "conftest.", or (3) at the end.

+   # Note that $ac_compile itself does not contain backslashes and begins

+   # with a dollar sign (not a hyphen), so the echo should work correctly.

+   # The option is referenced via a variable to avoid confusing sed.

+   lt_compile=`echo "$ac_compile" | $SED \

+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \

+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \

+   -e 's:$: $lt_compiler_flag:'`

+   (eval echo "\"\$as_me:15790: $lt_compile\"" >&5)

+   (eval "$lt_compile" 2>conftest.err)

+   ac_status=$?

+   cat conftest.err >&5

+   echo "$as_me:15794: \$? = $ac_status" >&5

+   if (exit $ac_status) && test -s "$ac_outfile"; then

+     # The compiler can only warn and ignore the option if not recognized

+     # So say no if there are warnings other than the usual output.

+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp

+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then

+       lt_prog_compiler_pic_works_GCJ=yes

+     fi

+   fi

+   $rm conftest*

+

+fi

+echo "$as_me:$LINENO: result: $lt_prog_compiler_pic_works_GCJ" >&5

+echo "${ECHO_T}$lt_prog_compiler_pic_works_GCJ" >&6

+

+if test x"$lt_prog_compiler_pic_works_GCJ" = xyes; then

+    case $lt_prog_compiler_pic_GCJ in

+     "" | " "*) ;;

+     *) lt_prog_compiler_pic_GCJ=" $lt_prog_compiler_pic_GCJ" ;;

+     esac

+else

+    lt_prog_compiler_pic_GCJ=

+     lt_prog_compiler_can_build_shared_GCJ=no

+fi

+

+fi

+case $host_os in

+  # For platforms which do not support PIC, -DPIC is meaningless:

+  *djgpp*)

+    lt_prog_compiler_pic_GCJ=

+    ;;

+  *)

+    lt_prog_compiler_pic_GCJ="$lt_prog_compiler_pic_GCJ"

+    ;;

+esac

+

+#

+# Check to make sure the static flag actually works.

+#

+wl=$lt_prog_compiler_wl_GCJ eval lt_tmp_static_flag=\"$lt_prog_compiler_static_GCJ\"

+echo "$as_me:$LINENO: checking if $compiler static flag $lt_tmp_static_flag works" >&5

+echo $ECHO_N "checking if $compiler static flag $lt_tmp_static_flag works... $ECHO_C" >&6

+if test "${lt_prog_compiler_static_works_GCJ+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  lt_prog_compiler_static_works_GCJ=no

+   save_LDFLAGS="$LDFLAGS"

+   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"

+   printf "$lt_simple_link_test_code" > conftest.$ac_ext

+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then

+     # The linker can only warn and ignore the option if not recognized

+     # So say no if there are warnings

+     if test -s conftest.err; then

+       # Append any errors to the config.log.

+       cat conftest.err 1>&5

+       $echo "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp

+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

+       if diff conftest.exp conftest.er2 >/dev/null; then

+         lt_prog_compiler_static_works_GCJ=yes

+       fi

+     else

+       lt_prog_compiler_static_works_GCJ=yes

+     fi

+   fi

+   $rm conftest*

+   LDFLAGS="$save_LDFLAGS"

+

+fi

+echo "$as_me:$LINENO: result: $lt_prog_compiler_static_works_GCJ" >&5

+echo "${ECHO_T}$lt_prog_compiler_static_works_GCJ" >&6

+

+if test x"$lt_prog_compiler_static_works_GCJ" = xyes; then

+    :

+else

+    lt_prog_compiler_static_GCJ=

+fi

+

+

+echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5

+echo $ECHO_N "checking if $compiler supports -c -o file.$ac_objext... $ECHO_C" >&6

+if test "${lt_cv_prog_compiler_c_o_GCJ+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  lt_cv_prog_compiler_c_o_GCJ=no

+   $rm -r conftest 2>/dev/null

+   mkdir conftest

+   cd conftest

+   mkdir out

+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext

+

+   lt_compiler_flag="-o out/conftest2.$ac_objext"

+   # Insert the option either (1) after the last *FLAGS variable, or

+   # (2) before a word containing "conftest.", or (3) at the end.

+   # Note that $ac_compile itself does not contain backslashes and begins

+   # with a dollar sign (not a hyphen), so the echo should work correctly.

+   lt_compile=`echo "$ac_compile" | $SED \

+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \

+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \

+   -e 's:$: $lt_compiler_flag:'`

+   (eval echo "\"\$as_me:15894: $lt_compile\"" >&5)

+   (eval "$lt_compile" 2>out/conftest.err)

+   ac_status=$?

+   cat out/conftest.err >&5

+   echo "$as_me:15898: \$? = $ac_status" >&5

+   if (exit $ac_status) && test -s out/conftest2.$ac_objext

+   then

+     # The compiler can only warn and ignore the option if not recognized

+     # So say no if there are warnings

+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp

+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2

+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then

+       lt_cv_prog_compiler_c_o_GCJ=yes

+     fi

+   fi

+   chmod u+w . 2>&5

+   $rm conftest*

+   # SGI C++ compiler will create directory out/ii_files/ for

+   # template instantiation

+   test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files

+   $rm out/* && rmdir out

+   cd ..

+   rmdir conftest

+   $rm conftest*

+

+fi

+echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_c_o_GCJ" >&5

+echo "${ECHO_T}$lt_cv_prog_compiler_c_o_GCJ" >&6

+

+

+hard_links="nottested"

+if test "$lt_cv_prog_compiler_c_o_GCJ" = no && test "$need_locks" != no; then

+  # do not overwrite the value of need_locks provided by the user

+  echo "$as_me:$LINENO: checking if we can lock with hard links" >&5

+echo $ECHO_N "checking if we can lock with hard links... $ECHO_C" >&6

+  hard_links=yes

+  $rm conftest*

+  ln conftest.a conftest.b 2>/dev/null && hard_links=no

+  touch conftest.a

+  ln conftest.a conftest.b 2>&5 || hard_links=no

+  ln conftest.a conftest.b 2>/dev/null && hard_links=no

+  echo "$as_me:$LINENO: result: $hard_links" >&5

+echo "${ECHO_T}$hard_links" >&6

+  if test "$hard_links" = no; then

+    { echo "$as_me:$LINENO: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5

+echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}

+    need_locks=warn

+  fi

+else

+  need_locks=no

+fi

+

+echo "$as_me:$LINENO: checking whether the $compiler linker ($LD) supports shared libraries" >&5

+echo $ECHO_N "checking whether the $compiler linker ($LD) supports shared libraries... $ECHO_C" >&6

+

+  runpath_var=

+  allow_undefined_flag_GCJ=

+  enable_shared_with_static_runtimes_GCJ=no

+  archive_cmds_GCJ=

+  archive_expsym_cmds_GCJ=

+  old_archive_From_new_cmds_GCJ=

+  old_archive_from_expsyms_cmds_GCJ=

+  export_dynamic_flag_spec_GCJ=

+  whole_archive_flag_spec_GCJ=

+  thread_safe_flag_spec_GCJ=

+  hardcode_libdir_flag_spec_GCJ=

+  hardcode_libdir_flag_spec_ld_GCJ=

+  hardcode_libdir_separator_GCJ=

+  hardcode_direct_GCJ=no

+  hardcode_minus_L_GCJ=no

+  hardcode_shlibpath_var_GCJ=unsupported

+  link_all_deplibs_GCJ=unknown

+  hardcode_automatic_GCJ=no

+  module_cmds_GCJ=

+  module_expsym_cmds_GCJ=

+  always_export_symbols_GCJ=no

+  export_symbols_cmds_GCJ='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'

+  # include_expsyms should be a list of space-separated symbols to be *always*

+  # included in the symbol list

+  include_expsyms_GCJ=

+  # exclude_expsyms can be an extended regexp of symbols to exclude

+  # it will be wrapped by ` (' and `)$', so one must not match beginning or

+  # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',

+  # as well as any symbol that contains `d'.

+  exclude_expsyms_GCJ="_GLOBAL_OFFSET_TABLE_"

+  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out

+  # platforms (ab)use it in PIC code, but their linkers get confused if

+  # the symbol is explicitly referenced.  Since portable code cannot

+  # rely on this symbol name, it's probably fine to never include it in

+  # preloaded symbol tables.

+  extract_expsyms_cmds=

+  # Just being paranoid about ensuring that cc_basename is set.

+  for cc_temp in $compiler""; do

+  case $cc_temp in

+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;

+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;

+    \-*) ;;

+    *) break;;

+  esac

+done

+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`

+

+  case $host_os in

+  cygwin* | mingw* | pw32*)

+    # FIXME: the MSVC++ port hasn't been tested in a loooong time

+    # When not using gcc, we currently assume that we are using

+    # Microsoft Visual C++.

+    if test "$GCC" != yes; then

+      with_gnu_ld=no

+    fi

+    ;;

+  interix*)

+    # we just hope/assume this is gcc and not c89 (= MSVC++)

+    with_gnu_ld=yes

+    ;;

+  openbsd*)

+    with_gnu_ld=no

+    ;;

+  esac

+

+  ld_shlibs_GCJ=yes

+  if test "$with_gnu_ld" = yes; then

+    # If archive_cmds runs LD, not CC, wlarc should be empty

+    wlarc='${wl}'

+

+    # Set some defaults for GNU ld with shared library support. These

+    # are reset later if shared libraries are not supported. Putting them

+    # here allows them to be overridden if necessary.

+    runpath_var=LD_RUN_PATH

+    hardcode_libdir_flag_spec_GCJ='${wl}--rpath ${wl}$libdir'

+    export_dynamic_flag_spec_GCJ='${wl}--export-dynamic'

+    # ancient GNU ld didn't support --whole-archive et. al.

+    if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then

+	whole_archive_flag_spec_GCJ="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'

+      else

+  	whole_archive_flag_spec_GCJ=

+    fi

+    supports_anon_versioning=no

+    case `$LD -v 2>/dev/null` in

+      *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11

+      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...

+      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...

+      *\ 2.11.*) ;; # other 2.11 versions

+      *) supports_anon_versioning=yes ;;

+    esac

+

+    # See if GNU ld supports shared libraries.

+    case $host_os in

+    aix3* | aix4* | aix5*)

+      # On AIX/PPC, the GNU linker is very broken

+      if test "$host_cpu" != ia64; then

+	ld_shlibs_GCJ=no

+	cat <<EOF 1>&2

+

+*** Warning: the GNU linker, at least up to release 2.9.1, is reported

+*** to be unable to reliably create shared libraries on AIX.

+*** Therefore, libtool is disabling shared libraries support.  If you

+*** really care for shared libraries, you may want to modify your PATH

+*** so that a non-GNU linker is found, and then restart.

+

+EOF

+      fi

+      ;;

+

+    amigaos*)

+      archive_cmds_GCJ='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'

+      hardcode_libdir_flag_spec_GCJ='-L$libdir'

+      hardcode_minus_L_GCJ=yes

+

+      # Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports

+      # that the semantics of dynamic libraries on AmigaOS, at least up

+      # to version 4, is to share data among multiple programs linked

+      # with the same dynamic library.  Since this doesn't match the

+      # behavior of shared libraries on other platforms, we can't use

+      # them.

+      ld_shlibs_GCJ=no

+      ;;

+

+    beos*)

+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	allow_undefined_flag_GCJ=unsupported

+	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc

+	# support --undefined.  This deserves some investigation.  FIXME

+	archive_cmds_GCJ='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+      else

+	ld_shlibs_GCJ=no

+      fi

+      ;;

+

+    cygwin* | mingw* | pw32*)

+      # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, GCJ) is actually meaningless,

+      # as there is no search path for DLLs.

+      hardcode_libdir_flag_spec_GCJ='-L$libdir'

+      allow_undefined_flag_GCJ=unsupported

+      always_export_symbols_GCJ=no

+      enable_shared_with_static_runtimes_GCJ=yes

+      export_symbols_cmds_GCJ='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS] /s/.* \([^ ]*\)/\1 DATA/'\'' | $SED -e '\''/^[AITW] /s/.* //'\'' | sort | uniq > $export_symbols'

+

+      if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then

+        archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'

+	# If the export-symbols file already is a .def file (1st line

+	# is EXPORTS), use it as is; otherwise, prepend...

+	archive_expsym_cmds_GCJ='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then

+	  cp $export_symbols $output_objdir/$soname.def;

+	else

+	  echo EXPORTS > $output_objdir/$soname.def;

+	  cat $export_symbols >> $output_objdir/$soname.def;

+	fi~

+	$CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'

+      else

+	ld_shlibs_GCJ=no

+      fi

+      ;;

+

+    interix3*)

+      hardcode_direct_GCJ=no

+      hardcode_shlibpath_var_GCJ=no

+      hardcode_libdir_flag_spec_GCJ='${wl}-rpath,$libdir'

+      export_dynamic_flag_spec_GCJ='${wl}-E'

+      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.

+      # Instead, shared libraries are loaded at an image base (0x10000000 by

+      # default) and relocated if they conflict, which is a slow very memory

+      # consuming and fragmenting process.  To avoid this, we pick a random,

+      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link

+      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.

+      archive_cmds_GCJ='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'

+      archive_expsym_cmds_GCJ='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'

+      ;;

+

+    linux*)

+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	tmp_addflag=

+	case $cc_basename,$host_cpu in

+	pgcc*)				# Portland Group C compiler

+	  whole_archive_flag_spec_GCJ='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'

+	  tmp_addflag=' $pic_flag'

+	  ;;

+	pgf77* | pgf90* | pgf95*)	# Portland Group f77 and f90 compilers

+	  whole_archive_flag_spec_GCJ='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'

+	  tmp_addflag=' $pic_flag -Mnomain' ;;

+	ecc*,ia64* | icc*,ia64*)		# Intel C compiler on ia64

+	  tmp_addflag=' -i_dynamic' ;;

+	efc*,ia64* | ifort*,ia64*)	# Intel Fortran compiler on ia64

+	  tmp_addflag=' -i_dynamic -nofor_main' ;;

+	ifc* | ifort*)			# Intel Fortran compiler

+	  tmp_addflag=' -nofor_main' ;;

+	esac

+	archive_cmds_GCJ='$CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+

+	if test $supports_anon_versioning = yes; then

+	  archive_expsym_cmds_GCJ='$echo "{ global:" > $output_objdir/$libname.ver~

+  cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~

+  $echo "local: *; };" >> $output_objdir/$libname.ver~

+	  $CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'

+	fi

+	link_all_deplibs_GCJ=no

+      else

+	ld_shlibs_GCJ=no

+      fi

+      ;;

+

+    netbsd* | netbsdelf*-gnu | knetbsd*-gnu)

+      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

+	archive_cmds_GCJ='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'

+	wlarc=

+      else

+	archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+	archive_expsym_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+      fi

+      ;;

+

+    solaris*)

+      if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then

+	ld_shlibs_GCJ=no

+	cat <<EOF 1>&2

+

+*** Warning: The releases 2.8.* of the GNU linker cannot reliably

+*** create shared libraries on Solaris systems.  Therefore, libtool

+*** is disabling shared libraries support.  We urge you to upgrade GNU

+*** binutils to release 2.9.1 or newer.  Another option is to modify

+*** your PATH or compiler configuration so that the native linker is

+*** used, and then restart.

+

+EOF

+      elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+	archive_expsym_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+      else

+	ld_shlibs_GCJ=no

+      fi

+      ;;

+

+    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)

+      case `$LD -v 2>&1` in

+        *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)

+	ld_shlibs_GCJ=no

+	cat <<_LT_EOF 1>&2

+

+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not

+*** reliably create shared libraries on SCO systems.  Therefore, libtool

+*** is disabling shared libraries support.  We urge you to upgrade GNU

+*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify

+*** your PATH or compiler configuration so that the native linker is

+*** used, and then restart.

+

+_LT_EOF

+	;;

+	*)

+	  if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	    hardcode_libdir_flag_spec_GCJ='`test -z "$SCOABSPATH" && echo ${wl}-rpath,$libdir`'

+	    archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib'

+	    archive_expsym_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname,-retain-symbols-file,$export_symbols -o $lib'

+	  else

+	    ld_shlibs_GCJ=no

+	  fi

+	;;

+      esac

+      ;;

+

+    sunos4*)

+      archive_cmds_GCJ='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'

+      wlarc=

+      hardcode_direct_GCJ=yes

+      hardcode_shlibpath_var_GCJ=no

+      ;;

+

+    *)

+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

+	archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

+	archive_expsym_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

+      else

+	ld_shlibs_GCJ=no

+      fi

+      ;;

+    esac

+

+    if test "$ld_shlibs_GCJ" = no; then

+      runpath_var=

+      hardcode_libdir_flag_spec_GCJ=

+      export_dynamic_flag_spec_GCJ=

+      whole_archive_flag_spec_GCJ=

+    fi

+  else

+    # PORTME fill in a description of your system's linker (not GNU ld)

+    case $host_os in

+    aix3*)

+      allow_undefined_flag_GCJ=unsupported

+      always_export_symbols_GCJ=yes

+      archive_expsym_cmds_GCJ='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'

+      # Note: this linker hardcodes the directories in LIBPATH if there

+      # are no directories specified by -L.

+      hardcode_minus_L_GCJ=yes

+      if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then

+	# Neither direct hardcoding nor static linking is supported with a

+	# broken collect2.

+	hardcode_direct_GCJ=unsupported

+      fi

+      ;;

+

+    aix4* | aix5*)

+      if test "$host_cpu" = ia64; then

+	# On IA64, the linker does run time linking by default, so we don't

+	# have to do anything special.

+	aix_use_runtimelinking=no

+	exp_sym_flag='-Bexport'

+	no_entry_flag=""

+      else

+	# If we're using GNU nm, then we don't want the "-C" option.

+	# -C means demangle to AIX nm, but means don't demangle with GNU nm

+	if $NM -V 2>&1 | grep 'GNU' > /dev/null; then

+	  export_symbols_cmds_GCJ='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols'

+	else

+	  export_symbols_cmds_GCJ='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols'

+	fi

+	aix_use_runtimelinking=no

+

+	# Test if we are trying to use run time linking or normal

+	# AIX style linking. If -brtl is somewhere in LDFLAGS, we

+	# need to do runtime linking.

+	case $host_os in aix4.[23]|aix4.[23].*|aix5*)

+	  for ld_flag in $LDFLAGS; do

+  	  if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then

+  	    aix_use_runtimelinking=yes

+  	    break

+  	  fi

+	  done

+	  ;;

+	esac

+

+	exp_sym_flag='-bexport'

+	no_entry_flag='-bnoentry'

+      fi

+

+      # When large executables or shared objects are built, AIX ld can

+      # have problems creating the table of contents.  If linking a library

+      # or program results in "error TOC overflow" add -mminimal-toc to

+      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not

+      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.

+

+      archive_cmds_GCJ=''

+      hardcode_direct_GCJ=yes

+      hardcode_libdir_separator_GCJ=':'

+      link_all_deplibs_GCJ=yes

+

+      if test "$GCC" = yes; then

+	case $host_os in aix4.[012]|aix4.[012].*)

+	# We only want to do this on AIX 4.2 and lower, the check

+	# below for broken collect2 doesn't work under 4.3+

+	  collect2name=`${CC} -print-prog-name=collect2`

+	  if test -f "$collect2name" && \

+  	   strings "$collect2name" | grep resolve_lib_name >/dev/null

+	  then

+  	  # We have reworked collect2

+  	  hardcode_direct_GCJ=yes

+	  else

+  	  # We have old collect2

+  	  hardcode_direct_GCJ=unsupported

+  	  # It fails to find uninstalled libraries when the uninstalled

+  	  # path is not listed in the libpath.  Setting hardcode_minus_L

+  	  # to unsupported forces relinking

+  	  hardcode_minus_L_GCJ=yes

+  	  hardcode_libdir_flag_spec_GCJ='-L$libdir'

+  	  hardcode_libdir_separator_GCJ=

+	  fi

+	  ;;

+	esac

+	shared_flag='-shared'

+	if test "$aix_use_runtimelinking" = yes; then

+	  shared_flag="$shared_flag "'${wl}-G'

+	fi

+      else

+	# not using gcc

+	if test "$host_cpu" = ia64; then

+  	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release

+  	# chokes on -Wl,-G. The following line is correct:

+	  shared_flag='-G'

+	else

+	  if test "$aix_use_runtimelinking" = yes; then

+	    shared_flag='${wl}-G'

+	  else

+	    shared_flag='${wl}-bM:SRE'

+	  fi

+	fi

+      fi

+

+      # It seems that -bexpall does not export symbols beginning with

+      # underscore (_), so it is better to generate a list of symbols to export.

+      always_export_symbols_GCJ=yes

+      if test "$aix_use_runtimelinking" = yes; then

+	# Warning - without using the other runtime loading flags (-brtl),

+	# -berok will link without error, but may produce a broken library.

+	allow_undefined_flag_GCJ='-berok'

+       # Determine the default libpath from the value encoded in an empty executable.

+       cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+int

+main ()

+{

+

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+

+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`

+# Check for a 64-bit object if we didn't find anything.

+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`; fi

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi

+

+       hardcode_libdir_flag_spec_GCJ='${wl}-blibpath:$libdir:'"$aix_libpath"

+	archive_expsym_cmds_GCJ="\$CC"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"

+       else

+	if test "$host_cpu" = ia64; then

+	  hardcode_libdir_flag_spec_GCJ='${wl}-R $libdir:/usr/lib:/lib'

+	  allow_undefined_flag_GCJ="-z nodefs"

+	  archive_expsym_cmds_GCJ="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"

+	else

+	 # Determine the default libpath from the value encoded in an empty executable.

+	 cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+int

+main ()

+{

+

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+

+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`

+# Check for a 64-bit object if we didn't find anything.

+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

+}'`; fi

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi

+

+	 hardcode_libdir_flag_spec_GCJ='${wl}-blibpath:$libdir:'"$aix_libpath"

+	  # Warning - without using the other run time loading flags,

+	  # -berok will link without error, but may produce a broken library.

+	  no_undefined_flag_GCJ=' ${wl}-bernotok'

+	  allow_undefined_flag_GCJ=' ${wl}-berok'

+	  # Exported symbols can be pulled into shared objects from archives

+	  whole_archive_flag_spec_GCJ='$convenience'

+	  archive_cmds_need_lc_GCJ=yes

+	  # This is similar to how AIX traditionally builds its shared libraries.

+	  archive_expsym_cmds_GCJ="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'

+	fi

+      fi

+      ;;

+

+    amigaos*)

+      archive_cmds_GCJ='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'

+      hardcode_libdir_flag_spec_GCJ='-L$libdir'

+      hardcode_minus_L_GCJ=yes

+      # see comment about different semantics on the GNU ld section

+      ld_shlibs_GCJ=no

+      ;;

+

+    bsdi[45]*)

+      export_dynamic_flag_spec_GCJ=-rdynamic

+      ;;

+

+    cygwin* | mingw* | pw32*)

+      # When not using gcc, we currently assume that we are using

+      # Microsoft Visual C++.

+      # hardcode_libdir_flag_spec is actually meaningless, as there is

+      # no search path for DLLs.

+      hardcode_libdir_flag_spec_GCJ=' '

+      allow_undefined_flag_GCJ=unsupported

+      # Tell ltmain to make .lib files, not .a files.

+      libext=lib

+      # Tell ltmain to make .dll files, not .so files.

+      shrext_cmds=".dll"

+      # FIXME: Setting linknames here is a bad hack.

+      archive_cmds_GCJ='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames='

+      # The linker will automatically build a .lib file if we build a DLL.

+      old_archive_From_new_cmds_GCJ='true'

+      # FIXME: Should let the user specify the lib program.

+      old_archive_cmds_GCJ='lib /OUT:$oldlib$oldobjs$old_deplibs'

+      fix_srcfile_path_GCJ='`cygpath -w "$srcfile"`'

+      enable_shared_with_static_runtimes_GCJ=yes

+      ;;

+

+    darwin* | rhapsody*)

+      case $host_os in

+        rhapsody* | darwin1.[012])

+         allow_undefined_flag_GCJ='${wl}-undefined ${wl}suppress'

+         ;;

+       *) # Darwin 1.3 on

+         if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then

+           allow_undefined_flag_GCJ='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'

+         else

+           case ${MACOSX_DEPLOYMENT_TARGET} in

+             10.[012])

+               allow_undefined_flag_GCJ='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'

+               ;;

+             10.*)

+               allow_undefined_flag_GCJ='${wl}-undefined ${wl}dynamic_lookup'

+               ;;

+           esac

+         fi

+         ;;

+      esac

+      archive_cmds_need_lc_GCJ=no

+      hardcode_direct_GCJ=no

+      hardcode_automatic_GCJ=yes

+      hardcode_shlibpath_var_GCJ=unsupported

+      whole_archive_flag_spec_GCJ=''

+      link_all_deplibs_GCJ=yes

+    if test "$GCC" = yes ; then

+    	output_verbose_link_cmd='echo'

+        archive_cmds_GCJ='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'

+      module_cmds_GCJ='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'

+      # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds

+      archive_expsym_cmds_GCJ='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+      module_expsym_cmds_GCJ='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+    else

+      case $cc_basename in

+        xlc*)

+         output_verbose_link_cmd='echo'

+         archive_cmds_GCJ='$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'

+         module_cmds_GCJ='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'

+          # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds

+         archive_expsym_cmds_GCJ='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+          module_expsym_cmds_GCJ='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

+          ;;

+       *)

+         ld_shlibs_GCJ=no

+          ;;

+      esac

+    fi

+      ;;

+

+    dgux*)

+      archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+      hardcode_libdir_flag_spec_GCJ='-L$libdir'

+      hardcode_shlibpath_var_GCJ=no

+      ;;

+

+    freebsd1*)

+      ld_shlibs_GCJ=no

+      ;;

+

+    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor

+    # support.  Future versions do this automatically, but an explicit c++rt0.o

+    # does not break anything, and helps significantly (at the cost of a little

+    # extra space).

+    freebsd2.2*)

+      archive_cmds_GCJ='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'

+      hardcode_libdir_flag_spec_GCJ='-R$libdir'

+      hardcode_direct_GCJ=yes

+      hardcode_shlibpath_var_GCJ=no

+      ;;

+

+    # Unfortunately, older versions of FreeBSD 2 do not have this feature.

+    freebsd2*)

+      archive_cmds_GCJ='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'

+      hardcode_direct_GCJ=yes

+      hardcode_minus_L_GCJ=yes

+      hardcode_shlibpath_var_GCJ=no

+      ;;

+

+    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.

+    freebsd* | dragonfly*)

+      archive_cmds_GCJ='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'

+      hardcode_libdir_flag_spec_GCJ='-R$libdir'

+      hardcode_direct_GCJ=yes

+      hardcode_shlibpath_var_GCJ=no

+      ;;

+

+    # GNU/kFreeBSD uses gcc -shared to do shared libraries.

+    kfreebsd*-gnu)

+      archive_cmds_GCJ='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'

+      hardcode_libdir_flag_spec_GCJ='-R$libdir'

+      hardcode_direct_GCJ=yes

+      hardcode_shlibpath_var_GCJ=no

+      link_all_deplibs_GCJ=no

+      ;;

+

+    hpux9*)

+      if test "$GCC" = yes; then

+	archive_cmds_GCJ='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

+      else

+	archive_cmds_GCJ='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

+      fi

+      hardcode_libdir_flag_spec_GCJ='${wl}+b ${wl}$libdir'

+      hardcode_libdir_separator_GCJ=:

+      hardcode_direct_GCJ=yes

+

+      # hardcode_minus_L: Not really in the search PATH,

+      # but as the default location of the library.

+      hardcode_minus_L_GCJ=yes

+      export_dynamic_flag_spec_GCJ='${wl}-E'

+      ;;

+

+    hpux10*)

+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then

+	archive_cmds_GCJ='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

+      else

+	archive_cmds_GCJ='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'

+      fi

+      if test "$with_gnu_ld" = no; then

+	hardcode_libdir_flag_spec_GCJ='${wl}+b ${wl}$libdir'

+	hardcode_libdir_separator_GCJ=:

+

+	hardcode_direct_GCJ=yes

+	export_dynamic_flag_spec_GCJ='${wl}-E'

+

+	# hardcode_minus_L: Not really in the search PATH,

+	# but as the default location of the library.

+	hardcode_minus_L_GCJ=yes

+      fi

+      ;;

+

+    hpux11*)

+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then

+	case $host_cpu in

+	hppa*64*)

+	  archive_cmds_GCJ='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	ia64*)

+	  archive_cmds_GCJ='$CC -shared ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	*)

+	  archive_cmds_GCJ='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	esac

+      else

+	case $host_cpu in

+	hppa*64*)

+	  archive_cmds_GCJ='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	ia64*)

+	  archive_cmds_GCJ='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	*)

+	  archive_cmds_GCJ='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

+	  ;;

+	esac

+      fi

+      if test "$with_gnu_ld" = no; then

+	hardcode_libdir_flag_spec_GCJ='${wl}+b ${wl}$libdir'

+	hardcode_libdir_separator_GCJ=:

+

+	case $host_cpu in

+	hppa*64*|ia64*)

+	  hardcode_libdir_flag_spec_ld_GCJ='+b $libdir'

+	  hardcode_direct_GCJ=no

+	  hardcode_shlibpath_var_GCJ=no

+	  ;;

+	*)

+	  hardcode_direct_GCJ=yes

+	  export_dynamic_flag_spec_GCJ='${wl}-E'

+

+	  # hardcode_minus_L: Not really in the search PATH,

+	  # but as the default location of the library.

+	  hardcode_minus_L_GCJ=yes

+	  ;;

+	esac

+      fi

+      ;;

+

+    irix5* | irix6* | nonstopux*)

+      if test "$GCC" = yes; then

+	archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+      else

+	archive_cmds_GCJ='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+	hardcode_libdir_flag_spec_ld_GCJ='-rpath $libdir'

+      fi

+      hardcode_libdir_flag_spec_GCJ='${wl}-rpath ${wl}$libdir'

+      hardcode_libdir_separator_GCJ=:

+      link_all_deplibs_GCJ=yes

+      ;;

+

+    netbsd* | netbsdelf*-gnu | knetbsd*-gnu)

+      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

+	archive_cmds_GCJ='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out

+      else

+	archive_cmds_GCJ='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF

+      fi

+      hardcode_libdir_flag_spec_GCJ='-R$libdir'

+      hardcode_direct_GCJ=yes

+      hardcode_shlibpath_var_GCJ=no

+      ;;

+

+    newsos6)

+      archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+      hardcode_direct_GCJ=yes

+      hardcode_libdir_flag_spec_GCJ='${wl}-rpath ${wl}$libdir'

+      hardcode_libdir_separator_GCJ=:

+      hardcode_shlibpath_var_GCJ=no

+      ;;

+

+    openbsd*)

+      hardcode_direct_GCJ=yes

+      hardcode_shlibpath_var_GCJ=no

+      if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

+	archive_cmds_GCJ='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds_GCJ='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'

+	hardcode_libdir_flag_spec_GCJ='${wl}-rpath,$libdir'

+	export_dynamic_flag_spec_GCJ='${wl}-E'

+      else

+       case $host_os in

+	 openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*)

+	   archive_cmds_GCJ='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'

+	   hardcode_libdir_flag_spec_GCJ='-R$libdir'

+	   ;;

+	 *)

+	   archive_cmds_GCJ='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'

+	   hardcode_libdir_flag_spec_GCJ='${wl}-rpath,$libdir'

+	   ;;

+       esac

+      fi

+      ;;

+

+    os2*)

+      hardcode_libdir_flag_spec_GCJ='-L$libdir'

+      hardcode_minus_L_GCJ=yes

+      allow_undefined_flag_GCJ=unsupported

+      archive_cmds_GCJ='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'

+      old_archive_From_new_cmds_GCJ='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'

+      ;;

+

+    osf3*)

+      if test "$GCC" = yes; then

+	allow_undefined_flag_GCJ=' ${wl}-expect_unresolved ${wl}\*'

+	archive_cmds_GCJ='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+      else

+	allow_undefined_flag_GCJ=' -expect_unresolved \*'

+	archive_cmds_GCJ='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+      fi

+      hardcode_libdir_flag_spec_GCJ='${wl}-rpath ${wl}$libdir'

+      hardcode_libdir_separator_GCJ=:

+      ;;

+

+    osf4* | osf5*)	# as osf3* with the addition of -msym flag

+      if test "$GCC" = yes; then

+	allow_undefined_flag_GCJ=' ${wl}-expect_unresolved ${wl}\*'

+	archive_cmds_GCJ='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

+	hardcode_libdir_flag_spec_GCJ='${wl}-rpath ${wl}$libdir'

+      else

+	allow_undefined_flag_GCJ=' -expect_unresolved \*'

+	archive_cmds_GCJ='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

+	archive_expsym_cmds_GCJ='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~

+	$LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib~$rm $lib.exp'

+

+	# Both c and cxx compiler support -rpath directly

+	hardcode_libdir_flag_spec_GCJ='-rpath $libdir'

+      fi

+      hardcode_libdir_separator_GCJ=:

+      ;;

+

+    solaris*)

+      no_undefined_flag_GCJ=' -z text'

+      if test "$GCC" = yes; then

+	wlarc='${wl}'

+	archive_cmds_GCJ='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds_GCJ='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

+	  $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp'

+      else

+	wlarc=''

+	archive_cmds_GCJ='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'

+	archive_expsym_cmds_GCJ='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

+  	$LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'

+      fi

+      hardcode_libdir_flag_spec_GCJ='-R$libdir'

+      hardcode_shlibpath_var_GCJ=no

+      case $host_os in

+      solaris2.[0-5] | solaris2.[0-5].*) ;;

+      *)

+ 	# The compiler driver will combine linker options so we

+ 	# cannot just pass the convience library names through

+ 	# without $wl, iff we do not link with $LD.

+ 	# Luckily, gcc supports the same syntax we need for Sun Studio.

+ 	# Supported since Solaris 2.6 (maybe 2.5.1?)

+ 	case $wlarc in

+ 	'')

+ 	  whole_archive_flag_spec_GCJ='-z allextract$convenience -z defaultextract' ;;

+ 	*)

+ 	  whole_archive_flag_spec_GCJ='${wl}-z ${wl}allextract`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}-z ${wl}defaultextract' ;;

+ 	esac ;;

+      esac

+      link_all_deplibs_GCJ=yes

+      ;;

+

+    sunos4*)

+      if test "x$host_vendor" = xsequent; then

+	# Use $CC to link under sequent, because it throws in some extra .o

+	# files that make .init and .fini sections work.

+	archive_cmds_GCJ='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'

+      else

+	archive_cmds_GCJ='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'

+      fi

+      hardcode_libdir_flag_spec_GCJ='-L$libdir'

+      hardcode_direct_GCJ=yes

+      hardcode_minus_L_GCJ=yes

+      hardcode_shlibpath_var_GCJ=no

+      ;;

+

+    sysv4)

+      case $host_vendor in

+	sni)

+	  archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+	  hardcode_direct_GCJ=yes # is this really true???

+	;;

+	siemens)

+	  ## LD is ld it makes a PLAMLIB

+	  ## CC just makes a GrossModule.

+	  archive_cmds_GCJ='$LD -G -o $lib $libobjs $deplibs $linker_flags'

+	  reload_cmds_GCJ='$CC -r -o $output$reload_objs'

+	  hardcode_direct_GCJ=no

+        ;;

+	motorola)

+	  archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+	  hardcode_direct_GCJ=no #Motorola manual says yes, but my tests say they lie

+	;;

+      esac

+      runpath_var='LD_RUN_PATH'

+      hardcode_shlibpath_var_GCJ=no

+      ;;

+

+    sysv4.3*)

+      archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+      hardcode_shlibpath_var_GCJ=no

+      export_dynamic_flag_spec_GCJ='-Bexport'

+      ;;

+

+    sysv4*MP*)

+      if test -d /usr/nec; then

+	archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+	hardcode_shlibpath_var_GCJ=no

+	runpath_var=LD_RUN_PATH

+	hardcode_runpath_var=yes

+	ld_shlibs_GCJ=yes

+      fi

+      ;;

+

+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7*)

+      no_undefined_flag_GCJ='${wl}-z,text'

+      archive_cmds_need_lc_GCJ=no

+      hardcode_shlibpath_var_GCJ=no

+      runpath_var='LD_RUN_PATH'

+

+      if test "$GCC" = yes; then

+	archive_cmds_GCJ='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds_GCJ='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+      else

+	archive_cmds_GCJ='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds_GCJ='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

+      fi

+      ;;

+

+    sysv5* | sco3.2v5* | sco5v6*)

+      # Note: We can NOT use -z defs as we might desire, because we do not

+      # link with -lc, and that would cause any symbols used from libc to

+      # always be unresolved, which means just about no library would

+      # ever link correctly.  If we're not using GNU ld we use -z text

+      # though, which does catch some bad symbols but isn't as heavy-handed

+      # as -z defs.

+      no_undefined_flag_GCJ='${wl}-z,text'

+      allow_undefined_flag_GCJ='${wl}-z,nodefs'

+      archive_cmds_need_lc_GCJ=no

+      hardcode_shlibpath_var_GCJ=no

+      hardcode_libdir_flag_spec_GCJ='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'

+      hardcode_libdir_separator_GCJ=':'

+      link_all_deplibs_GCJ=yes

+      export_dynamic_flag_spec_GCJ='${wl}-Bexport'

+      runpath_var='LD_RUN_PATH'

+

+      if test "$GCC" = yes; then

+	archive_cmds_GCJ='$CC -shared ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds_GCJ='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+      else

+	archive_cmds_GCJ='$CC -G ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+	archive_expsym_cmds_GCJ='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'

+      fi

+      ;;

+

+    uts4*)

+      archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

+      hardcode_libdir_flag_spec_GCJ='-L$libdir'

+      hardcode_shlibpath_var_GCJ=no

+      ;;

+

+    *)

+      ld_shlibs_GCJ=no

+      ;;

+    esac

+  fi

+

+echo "$as_me:$LINENO: result: $ld_shlibs_GCJ" >&5

+echo "${ECHO_T}$ld_shlibs_GCJ" >&6

+test "$ld_shlibs_GCJ" = no && can_build_shared=no

+

+#

+# Do we need to explicitly link libc?

+#

+case "x$archive_cmds_need_lc_GCJ" in

+x|xyes)

+  # Assume -lc should be added

+  archive_cmds_need_lc_GCJ=yes

+

+  if test "$enable_shared" = yes && test "$GCC" = yes; then

+    case $archive_cmds_GCJ in

+    *'~'*)

+      # FIXME: we may have to deal with multi-command sequences.

+      ;;

+    '$CC '*)

+      # Test whether the compiler implicitly links with -lc since on some

+      # systems, -lgcc has to come before -lc. If gcc already passes -lc

+      # to ld, don't add -lc before -lgcc.

+      echo "$as_me:$LINENO: checking whether -lc should be explicitly linked in" >&5

+echo $ECHO_N "checking whether -lc should be explicitly linked in... $ECHO_C" >&6

+      $rm conftest*

+      printf "$lt_simple_compile_test_code" > conftest.$ac_ext

+

+      if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } 2>conftest.err; then

+        soname=conftest

+        lib=conftest

+        libobjs=conftest.$ac_objext

+        deplibs=

+        wl=$lt_prog_compiler_wl_GCJ

+	pic_flag=$lt_prog_compiler_pic_GCJ

+        compiler_flags=-v

+        linker_flags=-v

+        verstring=

+        output_objdir=.

+        libname=conftest

+        lt_save_allow_undefined_flag=$allow_undefined_flag_GCJ

+        allow_undefined_flag_GCJ=

+        if { (eval echo "$as_me:$LINENO: \"$archive_cmds_GCJ 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\"") >&5

+  (eval $archive_cmds_GCJ 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }

+        then

+	  archive_cmds_need_lc_GCJ=no

+        else

+	  archive_cmds_need_lc_GCJ=yes

+        fi

+        allow_undefined_flag_GCJ=$lt_save_allow_undefined_flag

+      else

+        cat conftest.err 1>&5

+      fi

+      $rm conftest*

+      echo "$as_me:$LINENO: result: $archive_cmds_need_lc_GCJ" >&5

+echo "${ECHO_T}$archive_cmds_need_lc_GCJ" >&6

+      ;;

+    esac

+  fi

+  ;;

+esac

+

+echo "$as_me:$LINENO: checking dynamic linker characteristics" >&5

+echo $ECHO_N "checking dynamic linker characteristics... $ECHO_C" >&6

+library_names_spec=

+libname_spec='lib$name'

+soname_spec=

+shrext_cmds=".so"

+postinstall_cmds=

+postuninstall_cmds=

+finish_cmds=

+finish_eval=

+shlibpath_var=

+shlibpath_overrides_runpath=unknown

+version_type=none

+dynamic_linker="$host_os ld.so"

+sys_lib_dlsearch_path_spec="/lib /usr/lib"

+if test "$GCC" = yes; then

+  sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`

+  if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then

+    # if the path contains ";" then we assume it to be the separator

+    # otherwise default to the standard path separator (i.e. ":") - it is

+    # assumed that no part of a normal pathname contains ";" but that should

+    # okay in the real world where ";" in dirpaths is itself problematic.

+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`

+  else

+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`

+  fi

+else

+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"

+fi

+need_lib_prefix=unknown

+hardcode_into_libs=no

+

+# when you set need_version to no, make sure it does not cause -set_version

+# flags to be left without arguments

+need_version=unknown

+

+case $host_os in

+aix3*)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'

+  shlibpath_var=LIBPATH

+

+  # AIX 3 has no versioning support, so we append a major version to the name.

+  soname_spec='${libname}${release}${shared_ext}$major'

+  ;;

+

+aix4* | aix5*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  hardcode_into_libs=yes

+  if test "$host_cpu" = ia64; then

+    # AIX 5 supports IA64

+    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'

+    shlibpath_var=LD_LIBRARY_PATH

+  else

+    # With GCC up to 2.95.x, collect2 would create an import file

+    # for dependence libraries.  The import file would start with

+    # the line `#! .'.  This would cause the generated library to

+    # depend on `.', always an invalid library.  This was fixed in

+    # development snapshots of GCC prior to 3.0.

+    case $host_os in

+      aix4 | aix4.[01] | aix4.[01].*)

+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'

+	   echo ' yes '

+	   echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then

+	:

+      else

+	can_build_shared=no

+      fi

+      ;;

+    esac

+    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct

+    # soname into executable. Probably we can add versioning support to

+    # collect2, so additional links can be useful in future.

+    if test "$aix_use_runtimelinking" = yes; then

+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so

+      # instead of lib<name>.a to let people know that these are not

+      # typical AIX shared libraries.

+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+    else

+      # We preserve .a as extension for shared libraries through AIX4.2

+      # and later when we are not doing run time linking.

+      library_names_spec='${libname}${release}.a $libname.a'

+      soname_spec='${libname}${release}${shared_ext}$major'

+    fi

+    shlibpath_var=LIBPATH

+  fi

+  ;;

+

+amigaos*)

+  library_names_spec='$libname.ixlibrary $libname.a'

+  # Create ${libname}_ixlibrary.a entries in /sys/libs.

+  finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'

+  ;;

+

+beos*)

+  library_names_spec='${libname}${shared_ext}'

+  dynamic_linker="$host_os ld.so"

+  shlibpath_var=LIBRARY_PATH

+  ;;

+

+bsdi[45]*)

+  version_type=linux

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"

+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"

+  # the default ld.so.conf also contains /usr/contrib/lib and

+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow

+  # libtool to hard-code these into programs

+  ;;

+

+cygwin* | mingw* | pw32*)

+  version_type=windows

+  shrext_cmds=".dll"

+  need_version=no

+  need_lib_prefix=no

+

+  case $GCC,$host_os in

+  yes,cygwin* | yes,mingw* | yes,pw32*)

+    library_names_spec='$libname.dll.a'

+    # DLL is installed to $(libdir)/../bin by postinstall_cmds

+    postinstall_cmds='base_file=`basename \${file}`~

+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~

+      dldir=$destdir/`dirname \$dlpath`~

+      test -d \$dldir || mkdir -p \$dldir~

+      $install_prog $dir/$dlname \$dldir/$dlname~

+      chmod a+x \$dldir/$dlname'

+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~

+      dlpath=$dir/\$dldll~

+       $rm \$dlpath'

+    shlibpath_overrides_runpath=yes

+

+    case $host_os in

+    cygwin*)

+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'

+      soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'

+      sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"

+      ;;

+    mingw*)

+      # MinGW DLLs use traditional 'lib' prefix

+      soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'

+      sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`

+      if echo "$sys_lib_search_path_spec" | grep ';[c-zC-Z]:/' >/dev/null; then

+        # It is most probably a Windows format PATH printed by

+        # mingw gcc, but we are running on Cygwin. Gcc prints its search

+        # path with ; separators, and with drive letters. We can handle the

+        # drive letters (cygwin fileutils understands them), so leave them,

+        # especially as we might pass files found there to a mingw objdump,

+        # which wouldn't understand a cygwinified path. Ahh.

+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`

+      else

+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`

+      fi

+      ;;

+    pw32*)

+      # pw32 DLLs use 'pw' prefix rather than 'lib'

+      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'

+      ;;

+    esac

+    ;;

+

+  *)

+    library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib'

+    ;;

+  esac

+  dynamic_linker='Win32 ld.exe'

+  # FIXME: first we should search . and the directory the executable is in

+  shlibpath_var=PATH

+  ;;

+

+darwin* | rhapsody*)

+  dynamic_linker="$host_os dyld"

+  version_type=darwin

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext'

+  soname_spec='${libname}${release}${major}$shared_ext'

+  shlibpath_overrides_runpath=yes

+  shlibpath_var=DYLD_LIBRARY_PATH

+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'

+  # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same.

+  if test "$GCC" = yes; then

+    sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"`

+  else

+    sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib'

+  fi

+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'

+  ;;

+

+dgux*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  ;;

+

+freebsd1*)

+  dynamic_linker=no

+  ;;

+

+kfreebsd*-gnu)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  dynamic_linker='GNU ld.so'

+  ;;

+

+freebsd* | dragonfly*)

+  # DragonFly does not have aout.  When/if they implement a new

+  # versioning mechanism, adjust this.

+  if test -x /usr/bin/objformat; then

+    objformat=`/usr/bin/objformat`

+  else

+    case $host_os in

+    freebsd[123]*) objformat=aout ;;

+    *) objformat=elf ;;

+    esac

+  fi

+  version_type=freebsd-$objformat

+  case $version_type in

+    freebsd-elf*)

+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'

+      need_version=no

+      need_lib_prefix=no

+      ;;

+    freebsd-*)

+      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'

+      need_version=yes

+      ;;

+  esac

+  shlibpath_var=LD_LIBRARY_PATH

+  case $host_os in

+  freebsd2*)

+    shlibpath_overrides_runpath=yes

+    ;;

+  freebsd3.[01]* | freebsdelf3.[01]*)

+    shlibpath_overrides_runpath=yes

+    hardcode_into_libs=yes

+    ;;

+  freebsd3.[2-9]* | freebsdelf3.[2-9]* | \

+  freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)

+    shlibpath_overrides_runpath=no

+    hardcode_into_libs=yes

+    ;;

+  freebsd*) # from 4.6 on

+    shlibpath_overrides_runpath=yes

+    hardcode_into_libs=yes

+    ;;

+  esac

+  ;;

+

+gnu*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  hardcode_into_libs=yes

+  ;;

+

+hpux9* | hpux10* | hpux11*)

+  # Give a soname corresponding to the major version so that dld.sl refuses to

+  # link against other versions.

+  version_type=sunos

+  need_lib_prefix=no

+  need_version=no

+  case $host_cpu in

+  ia64*)

+    shrext_cmds='.so'

+    hardcode_into_libs=yes

+    dynamic_linker="$host_os dld.so"

+    shlibpath_var=LD_LIBRARY_PATH

+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+    soname_spec='${libname}${release}${shared_ext}$major'

+    if test "X$HPUX_IA64_MODE" = X32; then

+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"

+    else

+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"

+    fi

+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec

+    ;;

+   hppa*64*)

+     shrext_cmds='.sl'

+     hardcode_into_libs=yes

+     dynamic_linker="$host_os dld.sl"

+     shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH

+     shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.

+     library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+     soname_spec='${libname}${release}${shared_ext}$major'

+     sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"

+     sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec

+     ;;

+   *)

+    shrext_cmds='.sl'

+    dynamic_linker="$host_os dld.sl"

+    shlibpath_var=SHLIB_PATH

+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+    soname_spec='${libname}${release}${shared_ext}$major'

+    ;;

+  esac

+  # HP-UX runs *really* slowly unless shared libraries are mode 555.

+  postinstall_cmds='chmod 555 $lib'

+  ;;

+

+interix3*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  ;;

+

+irix5* | irix6* | nonstopux*)

+  case $host_os in

+    nonstopux*) version_type=nonstopux ;;

+    *)

+	if test "$lt_cv_prog_gnu_ld" = yes; then

+		version_type=linux

+	else

+		version_type=irix

+	fi ;;

+  esac

+  need_lib_prefix=no

+  need_version=no

+  soname_spec='${libname}${release}${shared_ext}$major'

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'

+  case $host_os in

+  irix5* | nonstopux*)

+    libsuff= shlibsuff=

+    ;;

+  *)

+    case $LD in # libtool.m4 will add one of these switches to LD

+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")

+      libsuff= shlibsuff= libmagic=32-bit;;

+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")

+      libsuff=32 shlibsuff=N32 libmagic=N32;;

+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")

+      libsuff=64 shlibsuff=64 libmagic=64-bit;;

+    *) libsuff= shlibsuff= libmagic=never-match;;

+    esac

+    ;;

+  esac

+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH

+  shlibpath_overrides_runpath=no

+  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"

+  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"

+  hardcode_into_libs=yes

+  ;;

+

+# No shared lib support for Linux oldld, aout, or coff.

+linux*oldld* | linux*aout* | linux*coff*)

+  dynamic_linker=no

+  ;;

+

+# This must be Linux ELF.

+linux*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  # This implies no fast_install, which is unacceptable.

+  # Some rework will be needed to allow for fast_install

+  # before this can be enabled.

+  hardcode_into_libs=yes

+

+  # Append ld.so.conf contents to the search path

+  if test -f /etc/ld.so.conf; then

+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;/^$/d' | tr '\n' ' '`

+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"

+  fi

+

+  # We used to test for /lib/ld.so.1 and disable shared libraries on

+  # powerpc, because MkLinux only supported shared libraries with the

+  # GNU dynamic linker.  Since this was broken with cross compilers,

+  # most powerpc-linux boxes support dynamic linking these days and

+  # people can always --disable-shared, the test was removed, and we

+  # assume the GNU/Linux dynamic linker is in use.

+  dynamic_linker='GNU/Linux ld.so'

+  ;;

+

+netbsdelf*-gnu)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  dynamic_linker='NetBSD ld.elf_so'

+  ;;

+

+knetbsd*-gnu)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=no

+  hardcode_into_libs=yes

+  dynamic_linker='GNU ld.so'

+  ;;

+

+netbsd*)

+  version_type=sunos

+  need_lib_prefix=no

+  need_version=no

+  if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'

+    dynamic_linker='NetBSD (a.out) ld.so'

+  else

+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

+    soname_spec='${libname}${release}${shared_ext}$major'

+    dynamic_linker='NetBSD ld.elf_so'

+  fi

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  hardcode_into_libs=yes

+  ;;

+

+newsos6)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  ;;

+

+nto-qnx*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  ;;

+

+openbsd*)

+  version_type=sunos

+  sys_lib_dlsearch_path_spec="/usr/lib"

+  need_lib_prefix=no

+  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.

+  case $host_os in

+    openbsd3.3 | openbsd3.3.*) need_version=yes ;;

+    *)                         need_version=no  ;;

+  esac

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

+    case $host_os in

+      openbsd2.[89] | openbsd2.[89].*)

+	shlibpath_overrides_runpath=no

+	;;

+      *)

+	shlibpath_overrides_runpath=yes

+	;;

+      esac

+  else

+    shlibpath_overrides_runpath=yes

+  fi

+  ;;

+

+os2*)

+  libname_spec='$name'

+  shrext_cmds=".dll"

+  need_lib_prefix=no

+  library_names_spec='$libname${shared_ext} $libname.a'

+  dynamic_linker='OS/2 ld.exe'

+  shlibpath_var=LIBPATH

+  ;;

+

+osf3* | osf4* | osf5*)

+  version_type=osf

+  need_lib_prefix=no

+  need_version=no

+  soname_spec='${libname}${release}${shared_ext}$major'

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  shlibpath_var=LD_LIBRARY_PATH

+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"

+  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"

+  ;;

+

+solaris*)

+  version_type=linux

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  hardcode_into_libs=yes

+  # ldd complains unless libraries are executable

+  postinstall_cmds='chmod +x $lib'

+  ;;

+

+sunos4*)

+  version_type=sunos

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'

+  shlibpath_var=LD_LIBRARY_PATH

+  shlibpath_overrides_runpath=yes

+  if test "$with_gnu_ld" = yes; then

+    need_lib_prefix=no

+  fi

+  need_version=yes

+  ;;

+

+sysv4 | sysv4.3*)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  case $host_vendor in

+    sni)

+      shlibpath_overrides_runpath=no

+      need_lib_prefix=no

+      export_dynamic_flag_spec='${wl}-Blargedynsym'

+      runpath_var=LD_RUN_PATH

+      ;;

+    siemens)

+      need_lib_prefix=no

+      ;;

+    motorola)

+      need_lib_prefix=no

+      need_version=no

+      shlibpath_overrides_runpath=no

+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'

+      ;;

+  esac

+  ;;

+

+sysv4*MP*)

+  if test -d /usr/nec ;then

+    version_type=linux

+    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'

+    soname_spec='$libname${shared_ext}.$major'

+    shlibpath_var=LD_LIBRARY_PATH

+  fi

+  ;;

+

+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)

+  version_type=freebsd-elf

+  need_lib_prefix=no

+  need_version=no

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  hardcode_into_libs=yes

+  if test "$with_gnu_ld" = yes; then

+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'

+    shlibpath_overrides_runpath=no

+  else

+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'

+    shlibpath_overrides_runpath=yes

+    case $host_os in

+      sco3.2v5*)

+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"

+	;;

+    esac

+  fi

+  sys_lib_dlsearch_path_spec='/usr/lib'

+  ;;

+

+uts4*)

+  version_type=linux

+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

+  soname_spec='${libname}${release}${shared_ext}$major'

+  shlibpath_var=LD_LIBRARY_PATH

+  ;;

+

+*)

+  dynamic_linker=no

+  ;;

+esac

+echo "$as_me:$LINENO: result: $dynamic_linker" >&5

+echo "${ECHO_T}$dynamic_linker" >&6

+test "$dynamic_linker" = no && can_build_shared=no

+

+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"

+if test "$GCC" = yes; then

+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"

+fi

+

+echo "$as_me:$LINENO: checking how to hardcode library paths into programs" >&5

+echo $ECHO_N "checking how to hardcode library paths into programs... $ECHO_C" >&6

+hardcode_action_GCJ=

+if test -n "$hardcode_libdir_flag_spec_GCJ" || \

+   test -n "$runpath_var_GCJ" || \

+   test "X$hardcode_automatic_GCJ" = "Xyes" ; then

+

+  # We can hardcode non-existant directories.

+  if test "$hardcode_direct_GCJ" != no &&

+     # If the only mechanism to avoid hardcoding is shlibpath_var, we

+     # have to relink, otherwise we might link with an installed library

+     # when we should be linking with a yet-to-be-installed one

+     ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, GCJ)" != no &&

+     test "$hardcode_minus_L_GCJ" != no; then

+    # Linking always hardcodes the temporary library directory.

+    hardcode_action_GCJ=relink

+  else

+    # We can link without hardcoding, and we can hardcode nonexisting dirs.

+    hardcode_action_GCJ=immediate

+  fi

+else

+  # We cannot hardcode anything, or else we can only hardcode existing

+  # directories.

+  hardcode_action_GCJ=unsupported

+fi

+echo "$as_me:$LINENO: result: $hardcode_action_GCJ" >&5

+echo "${ECHO_T}$hardcode_action_GCJ" >&6

+

+if test "$hardcode_action_GCJ" = relink; then

+  # Fast installation is not supported

+  enable_fast_install=no

+elif test "$shlibpath_overrides_runpath" = yes ||

+     test "$enable_shared" = no; then

+  # Fast installation is not necessary

+  enable_fast_install=needless

+fi

+

+

+# The else clause should only fire when bootstrapping the

+# libtool distribution, otherwise you forgot to ship ltmain.sh

+# with your package, and you will get complaints that there are

+# no rules to generate ltmain.sh.

+if test -f "$ltmain"; then

+  # See if we are running on zsh, and set the options which allow our commands through

+  # without removal of \ escapes.

+  if test -n "${ZSH_VERSION+set}" ; then

+    setopt NO_GLOB_SUBST

+  fi

+  # Now quote all the things that may contain metacharacters while being

+  # careful not to overquote the AC_SUBSTed values.  We take copies of the

+  # variables and quote the copies for generation of the libtool script.

+  for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC LTCFLAGS NM \

+    SED SHELL STRIP \

+    libname_spec library_names_spec soname_spec extract_expsyms_cmds \

+    old_striplib striplib file_magic_cmd finish_cmds finish_eval \

+    deplibs_check_method reload_flag reload_cmds need_locks \

+    lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \

+    lt_cv_sys_global_symbol_to_c_name_address \

+    sys_lib_search_path_spec sys_lib_dlsearch_path_spec \

+    old_postinstall_cmds old_postuninstall_cmds \

+    compiler_GCJ \

+    CC_GCJ \

+    LD_GCJ \

+    lt_prog_compiler_wl_GCJ \

+    lt_prog_compiler_pic_GCJ \

+    lt_prog_compiler_static_GCJ \

+    lt_prog_compiler_no_builtin_flag_GCJ \

+    export_dynamic_flag_spec_GCJ \

+    thread_safe_flag_spec_GCJ \

+    whole_archive_flag_spec_GCJ \

+    enable_shared_with_static_runtimes_GCJ \

+    old_archive_cmds_GCJ \

+    old_archive_from_new_cmds_GCJ \

+    predep_objects_GCJ \

+    postdep_objects_GCJ \

+    predeps_GCJ \

+    postdeps_GCJ \

+    compiler_lib_search_path_GCJ \

+    archive_cmds_GCJ \

+    archive_expsym_cmds_GCJ \

+    postinstall_cmds_GCJ \

+    postuninstall_cmds_GCJ \

+    old_archive_from_expsyms_cmds_GCJ \

+    allow_undefined_flag_GCJ \

+    no_undefined_flag_GCJ \

+    export_symbols_cmds_GCJ \

+    hardcode_libdir_flag_spec_GCJ \

+    hardcode_libdir_flag_spec_ld_GCJ \

+    hardcode_libdir_separator_GCJ \

+    hardcode_automatic_GCJ \

+    module_cmds_GCJ \

+    module_expsym_cmds_GCJ \

+    lt_cv_prog_compiler_c_o_GCJ \

+    exclude_expsyms_GCJ \

+    include_expsyms_GCJ; do

+

+    case $var in

+    old_archive_cmds_GCJ | \

+    old_archive_from_new_cmds_GCJ | \

+    archive_cmds_GCJ | \

+    archive_expsym_cmds_GCJ | \

+    module_cmds_GCJ | \

+    module_expsym_cmds_GCJ | \

+    old_archive_from_expsyms_cmds_GCJ | \

+    export_symbols_cmds_GCJ | \

+    extract_expsyms_cmds | reload_cmds | finish_cmds | \

+    postinstall_cmds | postuninstall_cmds | \

+    old_postinstall_cmds | old_postuninstall_cmds | \

+    sys_lib_search_path_spec | sys_lib_dlsearch_path_spec)

+      # Double-quote double-evaled strings.

+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\""

+      ;;

+    *)

+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\""

+      ;;

+    esac

+  done

+

+  case $lt_echo in

+  *'\$0 --fallback-echo"')

+    lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'`

+    ;;

+  esac

+

+cfgfile="$ofile"

+

+  cat <<__EOF__ >> "$cfgfile"

+# ### BEGIN LIBTOOL TAG CONFIG: $tagname

+

+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:

+

+# Shell to use when invoking shell scripts.

+SHELL=$lt_SHELL

+

+# Whether or not to build shared libraries.

+build_libtool_libs=$enable_shared

+

+# Whether or not to build static libraries.

+build_old_libs=$enable_static

+

+# Whether or not to add -lc for building shared libraries.

+build_libtool_need_lc=$archive_cmds_need_lc_GCJ

+

+# Whether or not to disallow shared libs when runtime libs are static

+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_GCJ

+

+# Whether or not to optimize for fast installation.

+fast_install=$enable_fast_install

+

+# The host system.

+host_alias=$host_alias

+host=$host

+host_os=$host_os

+

+# The build system.

+build_alias=$build_alias

+build=$build

+build_os=$build_os

+

+# An echo program that does not interpret backslashes.

+echo=$lt_echo

+

+# The archiver.

+AR=$lt_AR

+AR_FLAGS=$lt_AR_FLAGS

+

+# A C compiler.

+LTCC=$lt_LTCC

+

+# LTCC compiler flags.

+LTCFLAGS=$lt_LTCFLAGS

+

+# A language-specific compiler.

+CC=$lt_compiler_GCJ

+

+# Is the compiler the GNU C compiler?

+with_gcc=$GCC_GCJ

+

+# An ERE matcher.

+EGREP=$lt_EGREP

+

+# The linker used to build libraries.

+LD=$lt_LD_GCJ

+

+# Whether we need hard or soft links.

+LN_S=$lt_LN_S

+

+# A BSD-compatible nm program.

+NM=$lt_NM

+

+# A symbol stripping program

+STRIP=$lt_STRIP

+

+# Used to examine libraries when file_magic_cmd begins "file"

+MAGIC_CMD=$MAGIC_CMD

+

+# Used on cygwin: DLL creation program.

+DLLTOOL="$DLLTOOL"

+

+# Used on cygwin: object dumper.

+OBJDUMP="$OBJDUMP"

+

+# Used on cygwin: assembler.

+AS="$AS"

+

+# The name of the directory that contains temporary libtool files.

+objdir=$objdir

+

+# How to create reloadable object files.

+reload_flag=$lt_reload_flag

+reload_cmds=$lt_reload_cmds

+

+# How to pass a linker flag through the compiler.

+wl=$lt_lt_prog_compiler_wl_GCJ

+

+# Object file suffix (normally "o").

+objext="$ac_objext"

+

+# Old archive suffix (normally "a").

+libext="$libext"

+

+# Shared library suffix (normally ".so").

+shrext_cmds='$shrext_cmds'

+

+# Executable file suffix (normally "").

+exeext="$exeext"

+

+# Additional compiler flags for building library objects.

+pic_flag=$lt_lt_prog_compiler_pic_GCJ

+pic_mode=$pic_mode

+

+# What is the maximum length of a command?

+max_cmd_len=$lt_cv_sys_max_cmd_len

+

+# Does compiler simultaneously support -c and -o options?

+compiler_c_o=$lt_lt_cv_prog_compiler_c_o_GCJ

+

+# Must we lock files when doing compilation?

+need_locks=$lt_need_locks

+

+# Do we need the lib prefix for modules?

+need_lib_prefix=$need_lib_prefix

+

+# Do we need a version for libraries?

+need_version=$need_version

+

+# Whether dlopen is supported.

+dlopen_support=$enable_dlopen

+

+# Whether dlopen of programs is supported.

+dlopen_self=$enable_dlopen_self

+

+# Whether dlopen of statically linked programs is supported.

+dlopen_self_static=$enable_dlopen_self_static

+

+# Compiler flag to prevent dynamic linking.

+link_static_flag=$lt_lt_prog_compiler_static_GCJ

+

+# Compiler flag to turn off builtin functions.

+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_GCJ

+

+# Compiler flag to allow reflexive dlopens.

+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_GCJ

+

+# Compiler flag to generate shared objects directly from archives.

+whole_archive_flag_spec=$lt_whole_archive_flag_spec_GCJ

+

+# Compiler flag to generate thread-safe objects.

+thread_safe_flag_spec=$lt_thread_safe_flag_spec_GCJ

+

+# Library versioning type.

+version_type=$version_type

+

+# Format of library name prefix.

+libname_spec=$lt_libname_spec

+

+# List of archive names.  First name is the real one, the rest are links.

+# The last name is the one that the linker finds with -lNAME.

+library_names_spec=$lt_library_names_spec

+

+# The coded name of the library, if different from the real name.

+soname_spec=$lt_soname_spec

+

+# Commands used to build and install an old-style archive.

+RANLIB=$lt_RANLIB

+old_archive_cmds=$lt_old_archive_cmds_GCJ

+old_postinstall_cmds=$lt_old_postinstall_cmds

+old_postuninstall_cmds=$lt_old_postuninstall_cmds

+

+# Create an old-style archive from a shared archive.

+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_GCJ

+

+# Create a temporary old-style archive to link instead of a shared archive.

+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_GCJ

+

+# Commands used to build and install a shared archive.

+archive_cmds=$lt_archive_cmds_GCJ

+archive_expsym_cmds=$lt_archive_expsym_cmds_GCJ

+postinstall_cmds=$lt_postinstall_cmds

+postuninstall_cmds=$lt_postuninstall_cmds

+

+# Commands used to build a loadable module (assumed same as above if empty)

+module_cmds=$lt_module_cmds_GCJ

+module_expsym_cmds=$lt_module_expsym_cmds_GCJ

+

+# Commands to strip libraries.

+old_striplib=$lt_old_striplib

+striplib=$lt_striplib

+

+# Dependencies to place before the objects being linked to create a

+# shared library.

+predep_objects=$lt_predep_objects_GCJ

+

+# Dependencies to place after the objects being linked to create a

+# shared library.

+postdep_objects=$lt_postdep_objects_GCJ

+

+# Dependencies to place before the objects being linked to create a

+# shared library.

+predeps=$lt_predeps_GCJ

+

+# Dependencies to place after the objects being linked to create a

+# shared library.

+postdeps=$lt_postdeps_GCJ

+

+# The library search path used internally by the compiler when linking

+# a shared library.

+compiler_lib_search_path=$lt_compiler_lib_search_path_GCJ

+

+# Method to check whether dependent libraries are shared objects.

+deplibs_check_method=$lt_deplibs_check_method

+

+# Command to use when deplibs_check_method == file_magic.

+file_magic_cmd=$lt_file_magic_cmd

+

+# Flag that allows shared libraries with undefined symbols to be built.

+allow_undefined_flag=$lt_allow_undefined_flag_GCJ

+

+# Flag that forces no undefined symbols.

+no_undefined_flag=$lt_no_undefined_flag_GCJ

+

+# Commands used to finish a libtool library installation in a directory.

+finish_cmds=$lt_finish_cmds

+

+# Same as above, but a single script fragment to be evaled but not shown.

+finish_eval=$lt_finish_eval

+

+# Take the output of nm and produce a listing of raw symbols and C names.

+global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe

+

+# Transform the output of nm in a proper C declaration

+global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl

+

+# Transform the output of nm in a C name address pair

+global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address

+

+# This is the shared library runtime path variable.

+runpath_var=$runpath_var

+

+# This is the shared library path variable.

+shlibpath_var=$shlibpath_var

+

+# Is shlibpath searched before the hard-coded library search path?

+shlibpath_overrides_runpath=$shlibpath_overrides_runpath

+

+# How to hardcode a shared library path into an executable.

+hardcode_action=$hardcode_action_GCJ

+

+# Whether we should hardcode library paths into libraries.

+hardcode_into_libs=$hardcode_into_libs

+

+# Flag to hardcode \$libdir into a binary during linking.

+# This must work even if \$libdir does not exist.

+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_GCJ

+

+# If ld is used when linking, flag to hardcode \$libdir into

+# a binary during linking. This must work even if \$libdir does

+# not exist.

+hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld_GCJ

+

+# Whether we need a single -rpath flag with a separated argument.

+hardcode_libdir_separator=$lt_hardcode_libdir_separator_GCJ

+

+# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the

+# resulting binary.

+hardcode_direct=$hardcode_direct_GCJ

+

+# Set to yes if using the -LDIR flag during linking hardcodes DIR into the

+# resulting binary.

+hardcode_minus_L=$hardcode_minus_L_GCJ

+

+# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into

+# the resulting binary.

+hardcode_shlibpath_var=$hardcode_shlibpath_var_GCJ

+

+# Set to yes if building a shared library automatically hardcodes DIR into the library

+# and all subsequent libraries and executables linked against it.

+hardcode_automatic=$hardcode_automatic_GCJ

+

+# Variables whose values should be saved in libtool wrapper scripts and

+# restored at relink time.

+variables_saved_for_relink="$variables_saved_for_relink"

+

+# Whether libtool must link a program against all its dependency libraries.

+link_all_deplibs=$link_all_deplibs_GCJ

+

+# Compile-time system search path for libraries

+sys_lib_search_path_spec=$lt_sys_lib_search_path_spec

+

+# Run-time system search path for libraries

+sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec

+

+# Fix the shell variable \$srcfile for the compiler.

+fix_srcfile_path="$fix_srcfile_path_GCJ"

+

+# Set to yes if exported symbols are required.

+always_export_symbols=$always_export_symbols_GCJ

+

+# The commands to list exported symbols.

+export_symbols_cmds=$lt_export_symbols_cmds_GCJ

+

+# The commands to extract the exported symbol list from a shared archive.

+extract_expsyms_cmds=$lt_extract_expsyms_cmds

+

+# Symbols that should not be listed in the preloaded symbols.

+exclude_expsyms=$lt_exclude_expsyms_GCJ

+

+# Symbols that must always be exported.

+include_expsyms=$lt_include_expsyms_GCJ

+

+# ### END LIBTOOL TAG CONFIG: $tagname

+

+__EOF__

+

+

+else

+  # If there is no Makefile yet, we rely on a make rule to execute

+  # `config.status --recheck' to rerun these tests and create the

+  # libtool script then.

+  ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'`

+  if test -f "$ltmain_in"; then

+    test -f Makefile && make "$ltmain"

+  fi

+fi

+

+

+ac_ext=c

+ac_cpp='$CPP $CPPFLAGS'

+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_c_compiler_gnu

+

+CC="$lt_save_CC"

+

+	else

+	  tagname=""

+	fi

+	;;

+

+      RC)

+

+

+

+# Source file extension for RC test sources.

+ac_ext=rc

+

+# Object file extension for compiled RC test sources.

+objext=o

+objext_RC=$objext

+

+# Code to be used in simple compile tests

+lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }\n'

+

+# Code to be used in simple link tests

+lt_simple_link_test_code="$lt_simple_compile_test_code"

+

+# ltmain only uses $CC for tagged configurations so make sure $CC is set.

+

+# If no C compiler was specified, use CC.

+LTCC=${LTCC-"$CC"}

+

+# If no C compiler flags were specified, use CFLAGS.

+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}

+

+# Allow CC to be a program name with arguments.

+compiler=$CC

+

+

+# save warnings/boilerplate of simple test code

+ac_outfile=conftest.$ac_objext

+printf "$lt_simple_compile_test_code" >conftest.$ac_ext

+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err

+_lt_compiler_boilerplate=`cat conftest.err`

+$rm conftest*

+

+ac_outfile=conftest.$ac_objext

+printf "$lt_simple_link_test_code" >conftest.$ac_ext

+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err

+_lt_linker_boilerplate=`cat conftest.err`

+$rm conftest*

+

+

+# Allow CC to be a program name with arguments.

+lt_save_CC="$CC"

+CC=${RC-"windres"}

+compiler=$CC

+compiler_RC=$CC

+for cc_temp in $compiler""; do

+  case $cc_temp in

+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;

+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;

+    \-*) ;;

+    *) break;;

+  esac

+done

+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`

+

+lt_cv_prog_compiler_c_o_RC=yes

+

+# The else clause should only fire when bootstrapping the

+# libtool distribution, otherwise you forgot to ship ltmain.sh

+# with your package, and you will get complaints that there are

+# no rules to generate ltmain.sh.

+if test -f "$ltmain"; then

+  # See if we are running on zsh, and set the options which allow our commands through

+  # without removal of \ escapes.

+  if test -n "${ZSH_VERSION+set}" ; then

+    setopt NO_GLOB_SUBST

+  fi

+  # Now quote all the things that may contain metacharacters while being

+  # careful not to overquote the AC_SUBSTed values.  We take copies of the

+  # variables and quote the copies for generation of the libtool script.

+  for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC LTCFLAGS NM \

+    SED SHELL STRIP \

+    libname_spec library_names_spec soname_spec extract_expsyms_cmds \

+    old_striplib striplib file_magic_cmd finish_cmds finish_eval \

+    deplibs_check_method reload_flag reload_cmds need_locks \

+    lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \

+    lt_cv_sys_global_symbol_to_c_name_address \

+    sys_lib_search_path_spec sys_lib_dlsearch_path_spec \

+    old_postinstall_cmds old_postuninstall_cmds \

+    compiler_RC \

+    CC_RC \

+    LD_RC \

+    lt_prog_compiler_wl_RC \

+    lt_prog_compiler_pic_RC \

+    lt_prog_compiler_static_RC \

+    lt_prog_compiler_no_builtin_flag_RC \

+    export_dynamic_flag_spec_RC \

+    thread_safe_flag_spec_RC \

+    whole_archive_flag_spec_RC \

+    enable_shared_with_static_runtimes_RC \

+    old_archive_cmds_RC \

+    old_archive_from_new_cmds_RC \

+    predep_objects_RC \

+    postdep_objects_RC \

+    predeps_RC \

+    postdeps_RC \

+    compiler_lib_search_path_RC \

+    archive_cmds_RC \

+    archive_expsym_cmds_RC \

+    postinstall_cmds_RC \

+    postuninstall_cmds_RC \

+    old_archive_from_expsyms_cmds_RC \

+    allow_undefined_flag_RC \

+    no_undefined_flag_RC \

+    export_symbols_cmds_RC \

+    hardcode_libdir_flag_spec_RC \

+    hardcode_libdir_flag_spec_ld_RC \

+    hardcode_libdir_separator_RC \

+    hardcode_automatic_RC \

+    module_cmds_RC \

+    module_expsym_cmds_RC \

+    lt_cv_prog_compiler_c_o_RC \

+    exclude_expsyms_RC \

+    include_expsyms_RC; do

+

+    case $var in

+    old_archive_cmds_RC | \

+    old_archive_from_new_cmds_RC | \

+    archive_cmds_RC | \

+    archive_expsym_cmds_RC | \

+    module_cmds_RC | \

+    module_expsym_cmds_RC | \

+    old_archive_from_expsyms_cmds_RC | \

+    export_symbols_cmds_RC | \

+    extract_expsyms_cmds | reload_cmds | finish_cmds | \

+    postinstall_cmds | postuninstall_cmds | \

+    old_postinstall_cmds | old_postuninstall_cmds | \

+    sys_lib_search_path_spec | sys_lib_dlsearch_path_spec)

+      # Double-quote double-evaled strings.

+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\""

+      ;;

+    *)

+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\""

+      ;;

+    esac

+  done

+

+  case $lt_echo in

+  *'\$0 --fallback-echo"')

+    lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'`

+    ;;

+  esac

+

+cfgfile="$ofile"

+

+  cat <<__EOF__ >> "$cfgfile"

+# ### BEGIN LIBTOOL TAG CONFIG: $tagname

+

+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:

+

+# Shell to use when invoking shell scripts.

+SHELL=$lt_SHELL

+

+# Whether or not to build shared libraries.

+build_libtool_libs=$enable_shared

+

+# Whether or not to build static libraries.

+build_old_libs=$enable_static

+

+# Whether or not to add -lc for building shared libraries.

+build_libtool_need_lc=$archive_cmds_need_lc_RC

+

+# Whether or not to disallow shared libs when runtime libs are static

+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_RC

+

+# Whether or not to optimize for fast installation.

+fast_install=$enable_fast_install

+

+# The host system.

+host_alias=$host_alias

+host=$host

+host_os=$host_os

+

+# The build system.

+build_alias=$build_alias

+build=$build

+build_os=$build_os

+

+# An echo program that does not interpret backslashes.

+echo=$lt_echo

+

+# The archiver.

+AR=$lt_AR

+AR_FLAGS=$lt_AR_FLAGS

+

+# A C compiler.

+LTCC=$lt_LTCC

+

+# LTCC compiler flags.

+LTCFLAGS=$lt_LTCFLAGS

+

+# A language-specific compiler.

+CC=$lt_compiler_RC

+

+# Is the compiler the GNU C compiler?

+with_gcc=$GCC_RC

+

+# An ERE matcher.

+EGREP=$lt_EGREP

+

+# The linker used to build libraries.

+LD=$lt_LD_RC

+

+# Whether we need hard or soft links.

+LN_S=$lt_LN_S

+

+# A BSD-compatible nm program.

+NM=$lt_NM

+

+# A symbol stripping program

+STRIP=$lt_STRIP

+

+# Used to examine libraries when file_magic_cmd begins "file"

+MAGIC_CMD=$MAGIC_CMD

+

+# Used on cygwin: DLL creation program.

+DLLTOOL="$DLLTOOL"

+

+# Used on cygwin: object dumper.

+OBJDUMP="$OBJDUMP"

+

+# Used on cygwin: assembler.

+AS="$AS"

+

+# The name of the directory that contains temporary libtool files.

+objdir=$objdir

+

+# How to create reloadable object files.

+reload_flag=$lt_reload_flag

+reload_cmds=$lt_reload_cmds

+

+# How to pass a linker flag through the compiler.

+wl=$lt_lt_prog_compiler_wl_RC

+

+# Object file suffix (normally "o").

+objext="$ac_objext"

+

+# Old archive suffix (normally "a").

+libext="$libext"

+

+# Shared library suffix (normally ".so").

+shrext_cmds='$shrext_cmds'

+

+# Executable file suffix (normally "").

+exeext="$exeext"

+

+# Additional compiler flags for building library objects.

+pic_flag=$lt_lt_prog_compiler_pic_RC

+pic_mode=$pic_mode

+

+# What is the maximum length of a command?

+max_cmd_len=$lt_cv_sys_max_cmd_len

+

+# Does compiler simultaneously support -c and -o options?

+compiler_c_o=$lt_lt_cv_prog_compiler_c_o_RC

+

+# Must we lock files when doing compilation?

+need_locks=$lt_need_locks

+

+# Do we need the lib prefix for modules?

+need_lib_prefix=$need_lib_prefix

+

+# Do we need a version for libraries?

+need_version=$need_version

+

+# Whether dlopen is supported.

+dlopen_support=$enable_dlopen

+

+# Whether dlopen of programs is supported.

+dlopen_self=$enable_dlopen_self

+

+# Whether dlopen of statically linked programs is supported.

+dlopen_self_static=$enable_dlopen_self_static

+

+# Compiler flag to prevent dynamic linking.

+link_static_flag=$lt_lt_prog_compiler_static_RC

+

+# Compiler flag to turn off builtin functions.

+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_RC

+

+# Compiler flag to allow reflexive dlopens.

+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_RC

+

+# Compiler flag to generate shared objects directly from archives.

+whole_archive_flag_spec=$lt_whole_archive_flag_spec_RC

+

+# Compiler flag to generate thread-safe objects.

+thread_safe_flag_spec=$lt_thread_safe_flag_spec_RC

+

+# Library versioning type.

+version_type=$version_type

+

+# Format of library name prefix.

+libname_spec=$lt_libname_spec

+

+# List of archive names.  First name is the real one, the rest are links.

+# The last name is the one that the linker finds with -lNAME.

+library_names_spec=$lt_library_names_spec

+

+# The coded name of the library, if different from the real name.

+soname_spec=$lt_soname_spec

+

+# Commands used to build and install an old-style archive.

+RANLIB=$lt_RANLIB

+old_archive_cmds=$lt_old_archive_cmds_RC

+old_postinstall_cmds=$lt_old_postinstall_cmds

+old_postuninstall_cmds=$lt_old_postuninstall_cmds

+

+# Create an old-style archive from a shared archive.

+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_RC

+

+# Create a temporary old-style archive to link instead of a shared archive.

+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_RC

+

+# Commands used to build and install a shared archive.

+archive_cmds=$lt_archive_cmds_RC

+archive_expsym_cmds=$lt_archive_expsym_cmds_RC

+postinstall_cmds=$lt_postinstall_cmds

+postuninstall_cmds=$lt_postuninstall_cmds

+

+# Commands used to build a loadable module (assumed same as above if empty)

+module_cmds=$lt_module_cmds_RC

+module_expsym_cmds=$lt_module_expsym_cmds_RC

+

+# Commands to strip libraries.

+old_striplib=$lt_old_striplib

+striplib=$lt_striplib

+

+# Dependencies to place before the objects being linked to create a

+# shared library.

+predep_objects=$lt_predep_objects_RC

+

+# Dependencies to place after the objects being linked to create a

+# shared library.

+postdep_objects=$lt_postdep_objects_RC

+

+# Dependencies to place before the objects being linked to create a

+# shared library.

+predeps=$lt_predeps_RC

+

+# Dependencies to place after the objects being linked to create a

+# shared library.

+postdeps=$lt_postdeps_RC

+

+# The library search path used internally by the compiler when linking

+# a shared library.

+compiler_lib_search_path=$lt_compiler_lib_search_path_RC

+

+# Method to check whether dependent libraries are shared objects.

+deplibs_check_method=$lt_deplibs_check_method

+

+# Command to use when deplibs_check_method == file_magic.

+file_magic_cmd=$lt_file_magic_cmd

+

+# Flag that allows shared libraries with undefined symbols to be built.

+allow_undefined_flag=$lt_allow_undefined_flag_RC

+

+# Flag that forces no undefined symbols.

+no_undefined_flag=$lt_no_undefined_flag_RC

+

+# Commands used to finish a libtool library installation in a directory.

+finish_cmds=$lt_finish_cmds

+

+# Same as above, but a single script fragment to be evaled but not shown.

+finish_eval=$lt_finish_eval

+

+# Take the output of nm and produce a listing of raw symbols and C names.

+global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe

+

+# Transform the output of nm in a proper C declaration

+global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl

+

+# Transform the output of nm in a C name address pair

+global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address

+

+# This is the shared library runtime path variable.

+runpath_var=$runpath_var

+

+# This is the shared library path variable.

+shlibpath_var=$shlibpath_var

+

+# Is shlibpath searched before the hard-coded library search path?

+shlibpath_overrides_runpath=$shlibpath_overrides_runpath

+

+# How to hardcode a shared library path into an executable.

+hardcode_action=$hardcode_action_RC

+

+# Whether we should hardcode library paths into libraries.

+hardcode_into_libs=$hardcode_into_libs

+

+# Flag to hardcode \$libdir into a binary during linking.

+# This must work even if \$libdir does not exist.

+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_RC

+

+# If ld is used when linking, flag to hardcode \$libdir into

+# a binary during linking. This must work even if \$libdir does

+# not exist.

+hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld_RC

+

+# Whether we need a single -rpath flag with a separated argument.

+hardcode_libdir_separator=$lt_hardcode_libdir_separator_RC

+

+# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the

+# resulting binary.

+hardcode_direct=$hardcode_direct_RC

+

+# Set to yes if using the -LDIR flag during linking hardcodes DIR into the

+# resulting binary.

+hardcode_minus_L=$hardcode_minus_L_RC

+

+# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into

+# the resulting binary.

+hardcode_shlibpath_var=$hardcode_shlibpath_var_RC

+

+# Set to yes if building a shared library automatically hardcodes DIR into the library

+# and all subsequent libraries and executables linked against it.

+hardcode_automatic=$hardcode_automatic_RC

+

+# Variables whose values should be saved in libtool wrapper scripts and

+# restored at relink time.

+variables_saved_for_relink="$variables_saved_for_relink"

+

+# Whether libtool must link a program against all its dependency libraries.

+link_all_deplibs=$link_all_deplibs_RC

+

+# Compile-time system search path for libraries

+sys_lib_search_path_spec=$lt_sys_lib_search_path_spec

+

+# Run-time system search path for libraries

+sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec

+

+# Fix the shell variable \$srcfile for the compiler.

+fix_srcfile_path="$fix_srcfile_path_RC"

+

+# Set to yes if exported symbols are required.

+always_export_symbols=$always_export_symbols_RC

+

+# The commands to list exported symbols.

+export_symbols_cmds=$lt_export_symbols_cmds_RC

+

+# The commands to extract the exported symbol list from a shared archive.

+extract_expsyms_cmds=$lt_extract_expsyms_cmds

+

+# Symbols that should not be listed in the preloaded symbols.

+exclude_expsyms=$lt_exclude_expsyms_RC

+

+# Symbols that must always be exported.

+include_expsyms=$lt_include_expsyms_RC

+

+# ### END LIBTOOL TAG CONFIG: $tagname

+

+__EOF__

+

+

+else

+  # If there is no Makefile yet, we rely on a make rule to execute

+  # `config.status --recheck' to rerun these tests and create the

+  # libtool script then.

+  ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'`

+  if test -f "$ltmain_in"; then

+    test -f Makefile && make "$ltmain"

+  fi

+fi

+

+

+ac_ext=c

+ac_cpp='$CPP $CPPFLAGS'

+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_c_compiler_gnu

+

+CC="$lt_save_CC"

+

+	;;

+

+      *)

+	{ { echo "$as_me:$LINENO: error: Unsupported tag name: $tagname" >&5

+echo "$as_me: error: Unsupported tag name: $tagname" >&2;}

+   { (exit 1); exit 1; }; }

+	;;

+      esac

+

+      # Append the new tag name to the list of available tags.

+      if test -n "$tagname" ; then

+      available_tags="$available_tags $tagname"

+    fi

+    fi

+  done

+  IFS="$lt_save_ifs"

+

+  # Now substitute the updated list of available tags.

+  if eval "sed -e 's/^available_tags=.*\$/available_tags=\"$available_tags\"/' \"$ofile\" > \"${ofile}T\""; then

+    mv "${ofile}T" "$ofile"

+    chmod +x "$ofile"

+  else

+    rm -f "${ofile}T"

+    { { echo "$as_me:$LINENO: error: unable to update list of available tagged configurations." >&5

+echo "$as_me: error: unable to update list of available tagged configurations." >&2;}

+   { (exit 1); exit 1; }; }

+  fi

+fi

+

+

+

+# This can be used to rebuild libtool when needed

+LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh"

+

+# Always use our own libtool.

+LIBTOOL='$(SHELL) $(top_builddir)/libtool'

+

+# Prevent multiple expansion

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+# Check whether some low-level functions/files are available

+echo "$as_me:$LINENO: checking for ANSI C header files" >&5

+echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6

+if test "${ac_cv_header_stdc+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <stdlib.h>

+#include <stdarg.h>

+#include <string.h>

+#include <float.h>

+

+int

+main ()

+{

+

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_cv_header_stdc=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_cv_header_stdc=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+

+if test $ac_cv_header_stdc = yes; then

+  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <string.h>

+

+_ACEOF

+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

+  $EGREP "memchr" >/dev/null 2>&1; then

+  :

+else

+  ac_cv_header_stdc=no

+fi

+rm -f conftest*

+

+fi

+

+if test $ac_cv_header_stdc = yes; then

+  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <stdlib.h>

+

+_ACEOF

+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

+  $EGREP "free" >/dev/null 2>&1; then

+  :

+else

+  ac_cv_header_stdc=no

+fi

+rm -f conftest*

+

+fi

+

+if test $ac_cv_header_stdc = yes; then

+  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.

+  if test "$cross_compiling" = yes; then

+  :

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <ctype.h>

+#if ((' ' & 0x0FF) == 0x020)

+# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')

+# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))

+#else

+# define ISLOWER(c) \

+		   (('a' <= (c) && (c) <= 'i') \

+		     || ('j' <= (c) && (c) <= 'r') \

+		     || ('s' <= (c) && (c) <= 'z'))

+# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))

+#endif

+

+#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))

+int

+main ()

+{

+  int i;

+  for (i = 0; i < 256; i++)

+    if (XOR (islower (i), ISLOWER (i))

+	|| toupper (i) != TOUPPER (i))

+      exit(2);

+  exit (0);

+}

+_ACEOF

+rm -f conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  :

+else

+  echo "$as_me: program exited with status $ac_status" >&5

+echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+( exit $ac_status )

+ac_cv_header_stdc=no

+fi

+rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

+fi

+fi

+fi

+echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5

+echo "${ECHO_T}$ac_cv_header_stdc" >&6

+if test $ac_cv_header_stdc = yes; then

+

+cat >>confdefs.h <<\_ACEOF

+#define STDC_HEADERS 1

+_ACEOF

+

+fi

+

+

+

+for ac_header in ext/rope

+do

+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+else

+  # Is the header compilable?

+echo "$as_me:$LINENO: checking $ac_header usability" >&5

+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_includes_default

+#include <$ac_header>

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_header_compiler=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_header_compiler=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

+echo "${ECHO_T}$ac_header_compiler" >&6

+

+# Is the header present?

+echo "$as_me:$LINENO: checking $ac_header presence" >&5

+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <$ac_header>

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_c_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  ac_header_preproc=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  ac_header_preproc=no

+fi

+rm -f conftest.err conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

+echo "${ECHO_T}$ac_header_preproc" >&6

+

+# So?  What about this header?

+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in

+  yes:no: )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}

+    ac_header_preproc=yes

+    ;;

+  no:yes:* )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5

+echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5

+echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5

+echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5

+echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}

+    (

+      cat <<\_ASBOX

+## ------------------------------------ ##

+## Report this to opensource@google.com ##

+## ------------------------------------ ##

+_ASBOX

+    ) |

+      sed "s/^/$as_me: WARNING:     /" >&2

+    ;;

+esac

+echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  eval "$as_ac_Header=\$ac_header_preproc"

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+

+fi

+if test `eval echo '${'$as_ac_Header'}'` = yes; then

+  cat >>confdefs.h <<_ACEOF

+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

+_ACEOF

+

+fi

+

+done

+

+

+for ac_header in getopt.h

+do

+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+else

+  # Is the header compilable?

+echo "$as_me:$LINENO: checking $ac_header usability" >&5

+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_includes_default

+#include <$ac_header>

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_header_compiler=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_header_compiler=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

+echo "${ECHO_T}$ac_header_compiler" >&6

+

+# Is the header present?

+echo "$as_me:$LINENO: checking $ac_header presence" >&5

+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <$ac_header>

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_c_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  ac_header_preproc=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  ac_header_preproc=no

+fi

+rm -f conftest.err conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

+echo "${ECHO_T}$ac_header_preproc" >&6

+

+# So?  What about this header?

+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in

+  yes:no: )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}

+    ac_header_preproc=yes

+    ;;

+  no:yes:* )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5

+echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5

+echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5

+echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5

+echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}

+    (

+      cat <<\_ASBOX

+## ------------------------------------ ##

+## Report this to opensource@google.com ##

+## ------------------------------------ ##

+_ASBOX

+    ) |

+      sed "s/^/$as_me: WARNING:     /" >&2

+    ;;

+esac

+echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  eval "$as_ac_Header=\$ac_header_preproc"

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+

+fi

+if test `eval echo '${'$as_ac_Header'}'` = yes; then

+  cat >>confdefs.h <<_ACEOF

+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

+_ACEOF

+

+fi

+

+done

+

+

+for ac_header in malloc.h

+do

+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+else

+  # Is the header compilable?

+echo "$as_me:$LINENO: checking $ac_header usability" >&5

+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_includes_default

+#include <$ac_header>

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_header_compiler=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_header_compiler=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

+echo "${ECHO_T}$ac_header_compiler" >&6

+

+# Is the header present?

+echo "$as_me:$LINENO: checking $ac_header presence" >&5

+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <$ac_header>

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_c_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  ac_header_preproc=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  ac_header_preproc=no

+fi

+rm -f conftest.err conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

+echo "${ECHO_T}$ac_header_preproc" >&6

+

+# So?  What about this header?

+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in

+  yes:no: )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}

+    ac_header_preproc=yes

+    ;;

+  no:yes:* )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5

+echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5

+echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5

+echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5

+echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}

+    (

+      cat <<\_ASBOX

+## ------------------------------------ ##

+## Report this to opensource@google.com ##

+## ------------------------------------ ##

+_ASBOX

+    ) |

+      sed "s/^/$as_me: WARNING:     /" >&2

+    ;;

+esac

+echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  eval "$as_ac_Header=\$ac_header_preproc"

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+

+fi

+if test `eval echo '${'$as_ac_Header'}'` = yes; then

+  cat >>confdefs.h <<_ACEOF

+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

+_ACEOF

+

+fi

+

+done

+

+

+for ac_header in sys/mman.h

+do

+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+else

+  # Is the header compilable?

+echo "$as_me:$LINENO: checking $ac_header usability" >&5

+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_includes_default

+#include <$ac_header>

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_header_compiler=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_header_compiler=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

+echo "${ECHO_T}$ac_header_compiler" >&6

+

+# Is the header present?

+echo "$as_me:$LINENO: checking $ac_header presence" >&5

+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <$ac_header>

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_c_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  ac_header_preproc=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  ac_header_preproc=no

+fi

+rm -f conftest.err conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

+echo "${ECHO_T}$ac_header_preproc" >&6

+

+# So?  What about this header?

+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in

+  yes:no: )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}

+    ac_header_preproc=yes

+    ;;

+  no:yes:* )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5

+echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5

+echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5

+echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5

+echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}

+    (

+      cat <<\_ASBOX

+## ------------------------------------ ##

+## Report this to opensource@google.com ##

+## ------------------------------------ ##

+_ASBOX

+    ) |

+      sed "s/^/$as_me: WARNING:     /" >&2

+    ;;

+esac

+echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  eval "$as_ac_Header=\$ac_header_preproc"

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+

+fi

+if test `eval echo '${'$as_ac_Header'}'` = yes; then

+  cat >>confdefs.h <<_ACEOF

+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

+_ACEOF

+

+fi

+

+done

+

+

+for ac_header in sys/time.h

+do

+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+else

+  # Is the header compilable?

+echo "$as_me:$LINENO: checking $ac_header usability" >&5

+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_includes_default

+#include <$ac_header>

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_header_compiler=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_header_compiler=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

+echo "${ECHO_T}$ac_header_compiler" >&6

+

+# Is the header present?

+echo "$as_me:$LINENO: checking $ac_header presence" >&5

+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <$ac_header>

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_c_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  ac_header_preproc=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  ac_header_preproc=no

+fi

+rm -f conftest.err conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

+echo "${ECHO_T}$ac_header_preproc" >&6

+

+# So?  What about this header?

+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in

+  yes:no: )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}

+    ac_header_preproc=yes

+    ;;

+  no:yes:* )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5

+echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5

+echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5

+echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5

+echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}

+    (

+      cat <<\_ASBOX

+## ------------------------------------ ##

+## Report this to opensource@google.com ##

+## ------------------------------------ ##

+_ASBOX

+    ) |

+      sed "s/^/$as_me: WARNING:     /" >&2

+    ;;

+esac

+echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  eval "$as_ac_Header=\$ac_header_preproc"

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+

+fi

+if test `eval echo '${'$as_ac_Header'}'` = yes; then

+  cat >>confdefs.h <<_ACEOF

+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

+_ACEOF

+

+fi

+

+done

+

+

+for ac_header in unistd.h

+do

+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+else

+  # Is the header compilable?

+echo "$as_me:$LINENO: checking $ac_header usability" >&5

+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_includes_default

+#include <$ac_header>

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_header_compiler=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_header_compiler=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

+echo "${ECHO_T}$ac_header_compiler" >&6

+

+# Is the header present?

+echo "$as_me:$LINENO: checking $ac_header presence" >&5

+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <$ac_header>

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_c_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  ac_header_preproc=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  ac_header_preproc=no

+fi

+rm -f conftest.err conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

+echo "${ECHO_T}$ac_header_preproc" >&6

+

+# So?  What about this header?

+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in

+  yes:no: )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}

+    ac_header_preproc=yes

+    ;;

+  no:yes:* )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5

+echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5

+echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5

+echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5

+echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}

+    (

+      cat <<\_ASBOX

+## ------------------------------------ ##

+## Report this to opensource@google.com ##

+## ------------------------------------ ##

+_ASBOX

+    ) |

+      sed "s/^/$as_me: WARNING:     /" >&2

+    ;;

+esac

+echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  eval "$as_ac_Header=\$ac_header_preproc"

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+

+fi

+if test `eval echo '${'$as_ac_Header'}'` = yes; then

+  cat >>confdefs.h <<_ACEOF

+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

+_ACEOF

+

+fi

+

+done

+

+

+for ac_header in windows.h

+do

+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+else

+  # Is the header compilable?

+echo "$as_me:$LINENO: checking $ac_header usability" >&5

+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_includes_default

+#include <$ac_header>

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_header_compiler=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_header_compiler=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

+echo "${ECHO_T}$ac_header_compiler" >&6

+

+# Is the header present?

+echo "$as_me:$LINENO: checking $ac_header presence" >&5

+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <$ac_header>

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_c_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  ac_header_preproc=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  ac_header_preproc=no

+fi

+rm -f conftest.err conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

+echo "${ECHO_T}$ac_header_preproc" >&6

+

+# So?  What about this header?

+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in

+  yes:no: )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}

+    ac_header_preproc=yes

+    ;;

+  no:yes:* )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5

+echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5

+echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5

+echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5

+echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}

+    (

+      cat <<\_ASBOX

+## ------------------------------------ ##

+## Report this to opensource@google.com ##

+## ------------------------------------ ##

+_ASBOX

+    ) |

+      sed "s/^/$as_me: WARNING:     /" >&2

+    ;;

+esac

+echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  eval "$as_ac_Header=\$ac_header_preproc"

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+

+fi

+if test `eval echo '${'$as_ac_Header'}'` = yes; then

+  cat >>confdefs.h <<_ACEOF

+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

+_ACEOF

+

+fi

+

+done

+

+

+

+for ac_func in gettimeofday QueryPerformanceCounter

+do

+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

+echo "$as_me:$LINENO: checking for $ac_func" >&5

+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

+if eval "test \"\${$as_ac_var+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */

+#define $ac_func innocuous_$ac_func

+

+/* System header to define __stub macros and hopefully few prototypes,

+    which can conflict with char $ac_func (); below.

+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

+    <limits.h> exists even on freestanding compilers.  */

+

+#ifdef __STDC__

+# include <limits.h>

+#else

+# include <assert.h>

+#endif

+

+#undef $ac_func

+

+/* Override any gcc2 internal prototype to avoid an error.  */

+#ifdef __cplusplus

+extern "C"

+{

+#endif

+/* We use char because int might match the return type of a gcc2

+   builtin and then its argument prototype would still apply.  */

+char $ac_func ();

+/* The GNU C library defines this for functions which it implements

+    to always fail with ENOSYS.  Some functions are actually named

+    something starting with __ and the normal name is an alias.  */

+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

+choke me

+#else

+char (*f) () = $ac_func;

+#endif

+#ifdef __cplusplus

+}

+#endif

+

+int

+main ()

+{

+return f != $ac_func;

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  eval "$as_ac_var=yes"

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+eval "$as_ac_var=no"

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

+if test `eval echo '${'$as_ac_var'}'` = yes; then

+  cat >>confdefs.h <<_ACEOF

+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

+_ACEOF

+

+fi

+done

+

+

+

+for ac_func in memalign posix_memalign

+do

+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

+echo "$as_me:$LINENO: checking for $ac_func" >&5

+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

+if eval "test \"\${$as_ac_var+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */

+#define $ac_func innocuous_$ac_func

+

+/* System header to define __stub macros and hopefully few prototypes,

+    which can conflict with char $ac_func (); below.

+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

+    <limits.h> exists even on freestanding compilers.  */

+

+#ifdef __STDC__

+# include <limits.h>

+#else

+# include <assert.h>

+#endif

+

+#undef $ac_func

+

+/* Override any gcc2 internal prototype to avoid an error.  */

+#ifdef __cplusplus

+extern "C"

+{

+#endif

+/* We use char because int might match the return type of a gcc2

+   builtin and then its argument prototype would still apply.  */

+char $ac_func ();

+/* The GNU C library defines this for functions which it implements

+    to always fail with ENOSYS.  Some functions are actually named

+    something starting with __ and the normal name is an alias.  */

+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

+choke me

+#else

+char (*f) () = $ac_func;

+#endif

+#ifdef __cplusplus

+}

+#endif

+

+int

+main ()

+{

+return f != $ac_func;

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  eval "$as_ac_var=yes"

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+eval "$as_ac_var=no"

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

+if test `eval echo '${'$as_ac_var'}'` = yes; then

+  cat >>confdefs.h <<_ACEOF

+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

+_ACEOF

+

+fi

+done

+

+

+for ac_func in mprotect

+do

+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

+echo "$as_me:$LINENO: checking for $ac_func" >&5

+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

+if eval "test \"\${$as_ac_var+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */

+#define $ac_func innocuous_$ac_func

+

+/* System header to define __stub macros and hopefully few prototypes,

+    which can conflict with char $ac_func (); below.

+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

+    <limits.h> exists even on freestanding compilers.  */

+

+#ifdef __STDC__

+# include <limits.h>

+#else

+# include <assert.h>

+#endif

+

+#undef $ac_func

+

+/* Override any gcc2 internal prototype to avoid an error.  */

+#ifdef __cplusplus

+extern "C"

+{

+#endif

+/* We use char because int might match the return type of a gcc2

+   builtin and then its argument prototype would still apply.  */

+char $ac_func ();

+/* The GNU C library defines this for functions which it implements

+    to always fail with ENOSYS.  Some functions are actually named

+    something starting with __ and the normal name is an alias.  */

+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

+choke me

+#else

+char (*f) () = $ac_func;

+#endif

+#ifdef __cplusplus

+}

+#endif

+

+int

+main ()

+{

+return f != $ac_func;

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  eval "$as_ac_var=yes"

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+eval "$as_ac_var=no"

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

+if test `eval echo '${'$as_ac_var'}'` = yes; then

+  cat >>confdefs.h <<_ACEOF

+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

+_ACEOF

+

+fi

+done

+

+

+# Start of definitions needed by gflags package

+

+

+

+

+for ac_header in stdint.h sys/types.h inttypes.h

+do

+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+else

+  # Is the header compilable?

+echo "$as_me:$LINENO: checking $ac_header usability" >&5

+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_includes_default

+#include <$ac_header>

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_header_compiler=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_header_compiler=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

+echo "${ECHO_T}$ac_header_compiler" >&6

+

+# Is the header present?

+echo "$as_me:$LINENO: checking $ac_header presence" >&5

+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <$ac_header>

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_c_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  ac_header_preproc=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  ac_header_preproc=no

+fi

+rm -f conftest.err conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

+echo "${ECHO_T}$ac_header_preproc" >&6

+

+# So?  What about this header?

+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in

+  yes:no: )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}

+    ac_header_preproc=yes

+    ;;

+  no:yes:* )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5

+echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5

+echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5

+echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5

+echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}

+    (

+      cat <<\_ASBOX

+## ------------------------------------ ##

+## Report this to opensource@google.com ##

+## ------------------------------------ ##

+_ASBOX

+    ) |

+      sed "s/^/$as_me: WARNING:     /" >&2

+    ;;

+esac

+echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  eval "$as_ac_Header=\$ac_header_preproc"

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+

+fi

+if test `eval echo '${'$as_ac_Header'}'` = yes; then

+  cat >>confdefs.h <<_ACEOF

+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

+_ACEOF

+

+fi

+

+done

+

+

+for ac_header in fnmatch.h

+do

+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+else

+  # Is the header compilable?

+echo "$as_me:$LINENO: checking $ac_header usability" >&5

+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_includes_default

+#include <$ac_header>

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_header_compiler=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_header_compiler=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

+echo "${ECHO_T}$ac_header_compiler" >&6

+

+# Is the header present?

+echo "$as_me:$LINENO: checking $ac_header presence" >&5

+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

+cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <$ac_header>

+_ACEOF

+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } >/dev/null; then

+  if test -s conftest.err; then

+    ac_cpp_err=$ac_c_preproc_warn_flag

+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

+  else

+    ac_cpp_err=

+  fi

+else

+  ac_cpp_err=yes

+fi

+if test -z "$ac_cpp_err"; then

+  ac_header_preproc=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+  ac_header_preproc=no

+fi

+rm -f conftest.err conftest.$ac_ext

+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

+echo "${ECHO_T}$ac_header_preproc" >&6

+

+# So?  What about this header?

+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in

+  yes:no: )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}

+    ac_header_preproc=yes

+    ;;

+  no:yes:* )

+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5

+echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5

+echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5

+echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

+    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5

+echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}

+    (

+      cat <<\_ASBOX

+## ------------------------------------ ##

+## Report this to opensource@google.com ##

+## ------------------------------------ ##

+_ASBOX

+    ) |

+      sed "s/^/$as_me: WARNING:     /" >&2

+    ;;

+esac

+echo "$as_me:$LINENO: checking for $ac_header" >&5

+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

+if eval "test \"\${$as_ac_Header+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  eval "$as_ac_Header=\$ac_header_preproc"

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

+

+fi

+if test `eval echo '${'$as_ac_Header'}'` = yes; then

+  cat >>confdefs.h <<_ACEOF

+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

+_ACEOF

+

+fi

+

+done

+

+

+for ac_func in InitializeCriticalSection

+do

+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

+echo "$as_me:$LINENO: checking for $ac_func" >&5

+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

+if eval "test \"\${$as_ac_var+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */

+#define $ac_func innocuous_$ac_func

+

+/* System header to define __stub macros and hopefully few prototypes,

+    which can conflict with char $ac_func (); below.

+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

+    <limits.h> exists even on freestanding compilers.  */

+

+#ifdef __STDC__

+# include <limits.h>

+#else

+# include <assert.h>

+#endif

+

+#undef $ac_func

+

+/* Override any gcc2 internal prototype to avoid an error.  */

+#ifdef __cplusplus

+extern "C"

+{

+#endif

+/* We use char because int might match the return type of a gcc2

+   builtin and then its argument prototype would still apply.  */

+char $ac_func ();

+/* The GNU C library defines this for functions which it implements

+    to always fail with ENOSYS.  Some functions are actually named

+    something starting with __ and the normal name is an alias.  */

+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

+choke me

+#else

+char (*f) () = $ac_func;

+#endif

+#ifdef __cplusplus

+}

+#endif

+

+int

+main ()

+{

+return f != $ac_func;

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  eval "$as_ac_var=yes"

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+eval "$as_ac_var=no"

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

+if test `eval echo '${'$as_ac_var'}'` = yes; then

+  cat >>confdefs.h <<_ACEOF

+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

+_ACEOF

+

+fi

+done

+

+

+for ac_func in InterlockedCompareExchange

+do

+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

+echo "$as_me:$LINENO: checking for $ac_func" >&5

+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

+if eval "test \"\${$as_ac_var+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */

+#define $ac_func innocuous_$ac_func

+

+/* System header to define __stub macros and hopefully few prototypes,

+    which can conflict with char $ac_func (); below.

+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

+    <limits.h> exists even on freestanding compilers.  */

+

+#ifdef __STDC__

+# include <limits.h>

+#else

+# include <assert.h>

+#endif

+

+#undef $ac_func

+

+/* Override any gcc2 internal prototype to avoid an error.  */

+#ifdef __cplusplus

+extern "C"

+{

+#endif

+/* We use char because int might match the return type of a gcc2

+   builtin and then its argument prototype would still apply.  */

+char $ac_func ();

+/* The GNU C library defines this for functions which it implements

+    to always fail with ENOSYS.  Some functions are actually named

+    something starting with __ and the normal name is an alias.  */

+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

+choke me

+#else

+char (*f) () = $ac_func;

+#endif

+#ifdef __cplusplus

+}

+#endif

+

+int

+main ()

+{

+return f != $ac_func;

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  eval "$as_ac_var=yes"

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+eval "$as_ac_var=no"

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

+if test `eval echo '${'$as_ac_var'}'` = yes; then

+  cat >>confdefs.h <<_ACEOF

+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

+_ACEOF

+

+fi

+done

+

+

+

+for ac_func in strtoll strtoq

+do

+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

+echo "$as_me:$LINENO: checking for $ac_func" >&5

+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

+if eval "test \"\${$as_ac_var+set}\" = set"; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */

+#define $ac_func innocuous_$ac_func

+

+/* System header to define __stub macros and hopefully few prototypes,

+    which can conflict with char $ac_func (); below.

+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

+    <limits.h> exists even on freestanding compilers.  */

+

+#ifdef __STDC__

+# include <limits.h>

+#else

+# include <assert.h>

+#endif

+

+#undef $ac_func

+

+/* Override any gcc2 internal prototype to avoid an error.  */

+#ifdef __cplusplus

+extern "C"

+{

+#endif

+/* We use char because int might match the return type of a gcc2

+   builtin and then its argument prototype would still apply.  */

+char $ac_func ();

+/* The GNU C library defines this for functions which it implements

+    to always fail with ENOSYS.  Some functions are actually named

+    something starting with __ and the normal name is an alias.  */

+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

+choke me

+#else

+char (*f) () = $ac_func;

+#endif

+#ifdef __cplusplus

+}

+#endif

+

+int

+main ()

+{

+return f != $ac_func;

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  eval "$as_ac_var=yes"

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+eval "$as_ac_var=no"

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+fi

+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

+if test `eval echo '${'$as_ac_var'}'` = yes; then

+  cat >>confdefs.h <<_ACEOF

+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

+_ACEOF

+

+fi

+done

+

+echo "$as_me:$LINENO: checking for uint16_t" >&5

+echo $ECHO_N "checking for uint16_t... $ECHO_C" >&6

+if test "${ac_cv_type_uint16_t+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_includes_default

+int

+main ()

+{

+if ((uint16_t *) 0)

+  return 0;

+if (sizeof (uint16_t))

+  return 0;

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_cv_type_uint16_t=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_cv_type_uint16_t=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+fi

+echo "$as_me:$LINENO: result: $ac_cv_type_uint16_t" >&5

+echo "${ECHO_T}$ac_cv_type_uint16_t" >&6

+if test $ac_cv_type_uint16_t = yes; then

+

+cat >>confdefs.h <<_ACEOF

+#define HAVE_UINT16_T 1

+_ACEOF

+

+

+fi

+echo "$as_me:$LINENO: checking for u_int16_t" >&5

+echo $ECHO_N "checking for u_int16_t... $ECHO_C" >&6

+if test "${ac_cv_type_u_int16_t+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_includes_default

+int

+main ()

+{

+if ((u_int16_t *) 0)

+  return 0;

+if (sizeof (u_int16_t))

+  return 0;

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_cv_type_u_int16_t=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_cv_type_u_int16_t=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+fi

+echo "$as_me:$LINENO: result: $ac_cv_type_u_int16_t" >&5

+echo "${ECHO_T}$ac_cv_type_u_int16_t" >&6

+if test $ac_cv_type_u_int16_t = yes; then

+

+cat >>confdefs.h <<_ACEOF

+#define HAVE_U_INT16_T 1

+_ACEOF

+

+

+fi

+echo "$as_me:$LINENO: checking for __int16" >&5

+echo $ECHO_N "checking for __int16... $ECHO_C" >&6

+if test "${ac_cv_type___int16+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+$ac_includes_default

+int

+main ()

+{

+if ((__int16 *) 0)

+  return 0;

+if (sizeof (__int16))

+  return 0;

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_cv_type___int16=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_cv_type___int16=no

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+fi

+echo "$as_me:$LINENO: result: $ac_cv_type___int16" >&5

+echo "${ECHO_T}$ac_cv_type___int16" >&6

+if test $ac_cv_type___int16 = yes; then

+

+cat >>confdefs.h <<_ACEOF

+#define HAVE___INT16 1

+_ACEOF

+

+

+fi

+

+

+

+  echo "$as_me:$LINENO: checking for __attribute__" >&5

+echo $ECHO_N "checking for __attribute__... $ECHO_C" >&6

+  if test "${ac_cv___attribute__+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+

+    cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <stdlib.h>

+       static void foo(void) __attribute__ ((unused));

+       void foo(void) { exit(1); }

+int

+main ()

+{

+

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext

+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

+  (eval $ac_compile) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest.$ac_objext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  ac_cv___attribute__=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+ac_cv___attribute__=no

+

+fi

+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

+fi

+

+  if test "$ac_cv___attribute__" = "yes"; then

+

+cat >>confdefs.h <<\_ACEOF

+#define HAVE___ATTRIBUTE__ 1

+_ACEOF

+

+  fi

+  echo "$as_me:$LINENO: result: $ac_cv___attribute__" >&5

+echo "${ECHO_T}$ac_cv___attribute__" >&6

+

+

+

+

+

+

+ac_ext=c

+ac_cpp='$CPP $CPPFLAGS'

+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_c_compiler_gnu

+

+acx_pthread_ok=no

+

+# We used to check for pthread.h first, but this fails if pthread.h

+# requires special compiler flags (e.g. on True64 or Sequent).

+# It gets checked for in the link test anyway.

+

+# First of all, check if the user has set any of the PTHREAD_LIBS,

+# etcetera environment variables, and if threads linking works using

+# them:

+if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then

+        save_CFLAGS="$CFLAGS"

+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

+        save_LIBS="$LIBS"

+        LIBS="$PTHREAD_LIBS $LIBS"

+        echo "$as_me:$LINENO: checking for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS" >&5

+echo $ECHO_N "checking for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS... $ECHO_C" >&6

+        cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+/* Override any gcc2 internal prototype to avoid an error.  */

+#ifdef __cplusplus

+extern "C"

+#endif

+/* We use char because int might match the return type of a gcc2

+   builtin and then its argument prototype would still apply.  */

+char pthread_join ();

+int

+main ()

+{

+pthread_join ();

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  acx_pthread_ok=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+        echo "$as_me:$LINENO: result: $acx_pthread_ok" >&5

+echo "${ECHO_T}$acx_pthread_ok" >&6

+        if test x"$acx_pthread_ok" = xno; then

+                PTHREAD_LIBS=""

+                PTHREAD_CFLAGS=""

+        fi

+        LIBS="$save_LIBS"

+        CFLAGS="$save_CFLAGS"

+fi

+

+# We must check for the threads library under a number of different

+# names; the ordering is very important because some systems

+# (e.g. DEC) have both -lpthread and -lpthreads, where one of the

+# libraries is broken (non-POSIX).

+

+# Create a list of thread flags to try.  Items starting with a "-" are

+# C compiler flags, and other items are library names, except for "none"

+# which indicates that we try without any flags at all, and "pthread-config"

+# which is a program returning the flags for the Pth emulation library.

+

+acx_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"

+

+# The ordering *is* (sometimes) important.  Some notes on the

+# individual items follow:

+

+# pthreads: AIX (must check this before -lpthread)

+# none: in case threads are in libc; should be tried before -Kthread and

+#       other compiler flags to prevent continual compiler warnings

+# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)

+# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)

+# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)

+# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)

+# -pthreads: Solaris/gcc

+# -mthreads: Mingw32/gcc, Lynx/gcc

+# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it

+#      doesn't hurt to check since this sometimes defines pthreads too;

+#      also defines -D_REENTRANT)

+#      ... -mt is also the pthreads flag for HP/aCC

+# pthread: Linux, etcetera

+# --thread-safe: KAI C++

+# pthread-config: use pthread-config program (for GNU Pth library)

+

+case "${host_cpu}-${host_os}" in

+        *solaris*)

+

+        # On Solaris (at least, for some versions), libc contains stubbed

+        # (non-functional) versions of the pthreads routines, so link-based

+        # tests will erroneously succeed.  (We need to link with -pthreads/-mt/

+        # -lpthread.)  (The stubs are missing pthread_cleanup_push, or rather

+        # a function called by this macro, so we could check for that, but

+        # who knows whether they'll stub that too in a future libc.)  So,

+        # we'll just look for -pthreads and -lpthread first:

+

+        acx_pthread_flags="-pthreads pthread -mt -pthread $acx_pthread_flags"

+        ;;

+esac

+

+if test x"$acx_pthread_ok" = xno; then

+for flag in $acx_pthread_flags; do

+

+        case $flag in

+                none)

+                echo "$as_me:$LINENO: checking whether pthreads work without any flags" >&5

+echo $ECHO_N "checking whether pthreads work without any flags... $ECHO_C" >&6

+                ;;

+

+                -*)

+                echo "$as_me:$LINENO: checking whether pthreads work with $flag" >&5

+echo $ECHO_N "checking whether pthreads work with $flag... $ECHO_C" >&6

+                PTHREAD_CFLAGS="$flag"

+                ;;

+

+		pthread-config)

+		# Extract the first word of "pthread-config", so it can be a program name with args.

+set dummy pthread-config; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_acx_pthread_config+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$acx_pthread_config"; then

+  ac_cv_prog_acx_pthread_config="$acx_pthread_config" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_acx_pthread_config="yes"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+  test -z "$ac_cv_prog_acx_pthread_config" && ac_cv_prog_acx_pthread_config="no"

+fi

+fi

+acx_pthread_config=$ac_cv_prog_acx_pthread_config

+if test -n "$acx_pthread_config"; then

+  echo "$as_me:$LINENO: result: $acx_pthread_config" >&5

+echo "${ECHO_T}$acx_pthread_config" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+		if test x"$acx_pthread_config" = xno; then continue; fi

+		PTHREAD_CFLAGS="`pthread-config --cflags`"

+		PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"

+		;;

+

+                *)

+                echo "$as_me:$LINENO: checking for the pthreads library -l$flag" >&5

+echo $ECHO_N "checking for the pthreads library -l$flag... $ECHO_C" >&6

+                PTHREAD_LIBS="-l$flag"

+                ;;

+        esac

+

+        save_LIBS="$LIBS"

+        save_CFLAGS="$CFLAGS"

+        LIBS="$PTHREAD_LIBS $LIBS"

+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

+

+        # Check for various functions.  We must include pthread.h,

+        # since some functions may be macros.  (On the Sequent, we

+        # need a special flag -Kthread to make this header compile.)

+        # We check for pthread_join because it is in -lpthread on IRIX

+        # while pthread_create is in libc.  We check for pthread_attr_init

+        # due to DEC craziness with -lpthreads.  We check for

+        # pthread_cleanup_push because it is one of the few pthread

+        # functions on Solaris that doesn't have a non-functional libc stub.

+        # We try pthread_create on general principles.

+        cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <pthread.h>

+int

+main ()

+{

+pthread_t th; pthread_join(th, 0);

+                     pthread_attr_init(0); pthread_cleanup_push(0, 0);

+                     pthread_create(0,0,0,0); pthread_cleanup_pop(0);

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  acx_pthread_ok=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+

+        LIBS="$save_LIBS"

+        CFLAGS="$save_CFLAGS"

+

+        echo "$as_me:$LINENO: result: $acx_pthread_ok" >&5

+echo "${ECHO_T}$acx_pthread_ok" >&6

+        if test "x$acx_pthread_ok" = xyes; then

+                break;

+        fi

+

+        PTHREAD_LIBS=""

+        PTHREAD_CFLAGS=""

+done

+fi

+

+# Various other checks:

+if test "x$acx_pthread_ok" = xyes; then

+        save_LIBS="$LIBS"

+        LIBS="$PTHREAD_LIBS $LIBS"

+        save_CFLAGS="$CFLAGS"

+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

+

+        # Detect AIX lossage: JOINABLE attribute is called UNDETACHED.

+	echo "$as_me:$LINENO: checking for joinable pthread attribute" >&5

+echo $ECHO_N "checking for joinable pthread attribute... $ECHO_C" >&6

+	attr_name=unknown

+	for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do

+	    cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <pthread.h>

+int

+main ()

+{

+int attr=$attr; return attr;

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  attr_name=$attr; break

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+	done

+        echo "$as_me:$LINENO: result: $attr_name" >&5

+echo "${ECHO_T}$attr_name" >&6

+        if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then

+

+cat >>confdefs.h <<_ACEOF

+#define PTHREAD_CREATE_JOINABLE $attr_name

+_ACEOF

+

+        fi

+

+        echo "$as_me:$LINENO: checking if more special flags are required for pthreads" >&5

+echo $ECHO_N "checking if more special flags are required for pthreads... $ECHO_C" >&6

+        flag=no

+        case "${host_cpu}-${host_os}" in

+            *-aix* | *-freebsd* | *-darwin*) flag="-D_THREAD_SAFE";;

+            *solaris* | *-osf* | *-hpux*) flag="-D_REENTRANT";;

+        esac

+        echo "$as_me:$LINENO: result: ${flag}" >&5

+echo "${ECHO_T}${flag}" >&6

+        if test "x$flag" != xno; then

+            PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"

+        fi

+

+        LIBS="$save_LIBS"

+        CFLAGS="$save_CFLAGS"

+        # More AIX lossage: must compile with xlc_r or cc_r

+	if test x"$GCC" != xyes; then

+          for ac_prog in xlc_r cc_r

+do

+  # Extract the first word of "$ac_prog", so it can be a program name with args.

+set dummy $ac_prog; ac_word=$2

+echo "$as_me:$LINENO: checking for $ac_word" >&5

+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

+if test "${ac_cv_prog_PTHREAD_CC+set}" = set; then

+  echo $ECHO_N "(cached) $ECHO_C" >&6

+else

+  if test -n "$PTHREAD_CC"; then

+  ac_cv_prog_PTHREAD_CC="$PTHREAD_CC" # Let the user override the test.

+else

+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for ac_exec_ext in '' $ac_executable_extensions; do

+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

+    ac_cv_prog_PTHREAD_CC="$ac_prog"

+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

+    break 2

+  fi

+done

+done

+

+fi

+fi

+PTHREAD_CC=$ac_cv_prog_PTHREAD_CC

+if test -n "$PTHREAD_CC"; then

+  echo "$as_me:$LINENO: result: $PTHREAD_CC" >&5

+echo "${ECHO_T}$PTHREAD_CC" >&6

+else

+  echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+fi

+

+  test -n "$PTHREAD_CC" && break

+done

+test -n "$PTHREAD_CC" || PTHREAD_CC="${CC}"

+

+        else

+          PTHREAD_CC=$CC

+	fi

+

+	# The next part tries to detect GCC inconsistency with -shared on some

+	# architectures and systems. The problem is that in certain

+	# configurations, when -shared is specified, GCC "forgets" to

+	# internally use various flags which are still necessary.

+

+	#

+	# Prepare the flags

+	#

+	save_CFLAGS="$CFLAGS"

+	save_LIBS="$LIBS"

+	save_CC="$CC"

+

+	# Try with the flags determined by the earlier checks.

+	#

+	# -Wl,-z,defs forces link-time symbol resolution, so that the

+	# linking checks with -shared actually have any value

+	#

+	# FIXME: -fPIC is required for -shared on many architectures,

+	# so we specify it here, but the right way would probably be to

+	# properly detect whether it is actually required.

+	CFLAGS="-shared -fPIC -Wl,-z,defs $CFLAGS $PTHREAD_CFLAGS"

+	LIBS="$PTHREAD_LIBS $LIBS"

+	CC="$PTHREAD_CC"

+

+	# In order not to create several levels of indentation, we test

+	# the value of "$done" until we find the cure or run out of ideas.

+	done="no"

+

+	# First, make sure the CFLAGS we added are actually accepted by our

+	# compiler.  If not (and OS X's ld, for instance, does not accept -z),

+	# then we can't do this test.

+	if test x"$done" = xno; then

+	   echo "$as_me:$LINENO: checking whether to check for GCC pthread/shared inconsistencies" >&5

+echo $ECHO_N "checking whether to check for GCC pthread/shared inconsistencies... $ECHO_C" >&6

+	   cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+

+int

+main ()

+{

+

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  :

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+done=yes

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+

+	   if test "x$done" = xyes ; then

+	      echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+	   else

+	      echo "$as_me:$LINENO: result: yes" >&5

+echo "${ECHO_T}yes" >&6

+	   fi

+	fi

+

+	if test x"$done" = xno; then

+	   echo "$as_me:$LINENO: checking whether -pthread is sufficient with -shared" >&5

+echo $ECHO_N "checking whether -pthread is sufficient with -shared... $ECHO_C" >&6

+	   cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <pthread.h>

+int

+main ()

+{

+pthread_t th; pthread_join(th, 0);

+	      pthread_attr_init(0); pthread_cleanup_push(0, 0);

+	      pthread_create(0,0,0,0); pthread_cleanup_pop(0);

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  done=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+

+	   if test "x$done" = xyes; then

+	      echo "$as_me:$LINENO: result: yes" >&5

+echo "${ECHO_T}yes" >&6

+	   else

+	      echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+	   fi

+	fi

+

+	#

+	# Linux gcc on some architectures such as mips/mipsel forgets

+	# about -lpthread

+	#

+	if test x"$done" = xno; then

+	   echo "$as_me:$LINENO: checking whether -lpthread fixes that" >&5

+echo $ECHO_N "checking whether -lpthread fixes that... $ECHO_C" >&6

+	   LIBS="-lpthread $PTHREAD_LIBS $save_LIBS"

+	   cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <pthread.h>

+int

+main ()

+{

+pthread_t th; pthread_join(th, 0);

+	      pthread_attr_init(0); pthread_cleanup_push(0, 0);

+	      pthread_create(0,0,0,0); pthread_cleanup_pop(0);

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  done=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+

+	   if test "x$done" = xyes; then

+	      echo "$as_me:$LINENO: result: yes" >&5

+echo "${ECHO_T}yes" >&6

+	      PTHREAD_LIBS="-lpthread $PTHREAD_LIBS"

+	   else

+	      echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+	   fi

+	fi

+	#

+	# FreeBSD 4.10 gcc forgets to use -lc_r instead of -lc

+	#

+	if test x"$done" = xno; then

+	   echo "$as_me:$LINENO: checking whether -lc_r fixes that" >&5

+echo $ECHO_N "checking whether -lc_r fixes that... $ECHO_C" >&6

+	   LIBS="-lc_r $PTHREAD_LIBS $save_LIBS"

+	   cat >conftest.$ac_ext <<_ACEOF

+/* confdefs.h.  */

+_ACEOF

+cat confdefs.h >>conftest.$ac_ext

+cat >>conftest.$ac_ext <<_ACEOF

+/* end confdefs.h.  */

+#include <pthread.h>

+int

+main ()

+{

+pthread_t th; pthread_join(th, 0);

+	        pthread_attr_init(0); pthread_cleanup_push(0, 0);

+	        pthread_create(0,0,0,0); pthread_cleanup_pop(0);

+  ;

+  return 0;

+}

+_ACEOF

+rm -f conftest.$ac_objext conftest$ac_exeext

+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

+  (eval $ac_link) 2>conftest.er1

+  ac_status=$?

+  grep -v '^ *+' conftest.er1 >conftest.err

+  rm -f conftest.er1

+  cat conftest.err >&5

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); } &&

+	 { ac_try='test -z "$ac_c_werror_flag"			 || test ! -s conftest.err'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; } &&

+	 { ac_try='test -s conftest$ac_exeext'

+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

+  (eval $ac_try) 2>&5

+  ac_status=$?

+  echo "$as_me:$LINENO: \$? = $ac_status" >&5

+  (exit $ac_status); }; }; then

+  done=yes

+else

+  echo "$as_me: failed program was:" >&5

+sed 's/^/| /' conftest.$ac_ext >&5

+

+fi

+rm -f conftest.err conftest.$ac_objext \

+      conftest$ac_exeext conftest.$ac_ext

+

+	   if test "x$done" = xyes; then

+	      echo "$as_me:$LINENO: result: yes" >&5

+echo "${ECHO_T}yes" >&6

+	      PTHREAD_LIBS="-lc_r $PTHREAD_LIBS"

+	   else

+	      echo "$as_me:$LINENO: result: no" >&5

+echo "${ECHO_T}no" >&6

+	   fi

+	fi

+	if test x"$done" = xno; then

+	   # OK, we have run out of ideas

+	   { echo "$as_me:$LINENO: WARNING: Impossible to determine how to use pthreads with shared libraries" >&5

+echo "$as_me: WARNING: Impossible to determine how to use pthreads with shared libraries" >&2;}

+

+	   # so it's not safe to assume that we may use pthreads

+	   acx_pthread_ok=no

+	fi

+

+	CFLAGS="$save_CFLAGS"

+	LIBS="$save_LIBS"

+	CC="$save_CC"

+else

+        PTHREAD_CC="$CC"

+fi

+

+

+

+

+

+# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:

+if test x"$acx_pthread_ok" = xyes; then

+

+cat >>confdefs.h <<\_ACEOF

+#define HAVE_PTHREAD 1

+_ACEOF

+

+        :

+else

+        acx_pthread_ok=no

+

+fi

+ac_ext=c

+ac_cpp='$CPP $CPPFLAGS'

+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

+ac_compiler_gnu=$ac_cv_c_compiler_gnu

+

+

+

+# End of definitions needed by gflags package

+

+          ac_config_files="$ac_config_files Makefile"

+

+cat >confcache <<\_ACEOF

+# This file is a shell script that caches the results of configure

+# tests run on this system so they can be shared between configure

+# scripts and configure runs, see configure's option --config-cache.

+# It is not useful on other systems.  If it contains results you don't

+# want to keep, you may remove or edit it.

+#

+# config.status only pays attention to the cache file if you give it

+# the --recheck option to rerun configure.

+#

+# `ac_cv_env_foo' variables (set or unset) will be overridden when

+# loading this file, other *unset* `ac_cv_foo' will be assigned the

+# following values.

+

+_ACEOF

+

+# The following way of writing the cache mishandles newlines in values,

+# but we know of no workaround that is simple, portable, and efficient.

+# So, don't put newlines in cache variables' values.

+# Ultrix sh set writes to stderr and can't be redirected directly,

+# and sets the high bit in the cache file unless we assign to the vars.

+{

+  (set) 2>&1 |

+    case `(ac_space=' '; set | grep ac_space) 2>&1` in

+    *ac_space=\ *)

+      # `set' does not quote correctly, so add quotes (double-quote

+      # substitution turns \\\\ into \\, and sed turns \\ into \).

+      sed -n \

+	"s/'/'\\\\''/g;

+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"

+      ;;

+    *)

+      # `set' quotes correctly as required by POSIX, so do not add quotes.

+      sed -n \

+	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"

+      ;;

+    esac;

+} |

+  sed '

+     t clear

+     : clear

+     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/

+     t end

+     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/

+     : end' >>confcache

+if diff $cache_file confcache >/dev/null 2>&1; then :; else

+  if test -w $cache_file; then

+    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"

+    cat confcache >$cache_file

+  else

+    echo "not updating unwritable cache $cache_file"

+  fi

+fi

+rm -f confcache

+

+test "x$prefix" = xNONE && prefix=$ac_default_prefix

+# Let make expand exec_prefix.

+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'

+

+# VPATH may cause trouble with some makes, so we remove $(srcdir),

+# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and

+# trailing colons and then remove the whole line if VPATH becomes empty

+# (actually we leave an empty line to preserve line numbers).

+if test "x$srcdir" = x.; then

+  ac_vpsub='/^[	 ]*VPATH[	 ]*=/{

+s/:*\$(srcdir):*/:/;

+s/:*\${srcdir}:*/:/;

+s/:*@srcdir@:*/:/;

+s/^\([^=]*=[	 ]*\):*/\1/;

+s/:*$//;

+s/^[^=]*=[	 ]*$//;

+}'

+fi

+

+DEFS=-DHAVE_CONFIG_H

+

+ac_libobjs=

+ac_ltlibobjs=

+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue

+  # 1. Remove the extension, and $U if already installed.

+  ac_i=`echo "$ac_i" |

+	 sed 's/\$U\././;s/\.o$//;s/\.obj$//'`

+  # 2. Add them.

+  ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"

+  ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'

+done

+LIBOBJS=$ac_libobjs

+

+LTLIBOBJS=$ac_ltlibobjs

+

+

+if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then

+  { { echo "$as_me:$LINENO: error: conditional \"AMDEP\" was never defined.

+Usually this means the macro was only invoked conditionally." >&5

+echo "$as_me: error: conditional \"AMDEP\" was never defined.

+Usually this means the macro was only invoked conditionally." >&2;}

+   { (exit 1); exit 1; }; }

+fi

+if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then

+  { { echo "$as_me:$LINENO: error: conditional \"am__fastdepCC\" was never defined.

+Usually this means the macro was only invoked conditionally." >&5

+echo "$as_me: error: conditional \"am__fastdepCC\" was never defined.

+Usually this means the macro was only invoked conditionally." >&2;}

+   { (exit 1); exit 1; }; }

+fi

+if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then

+  { { echo "$as_me:$LINENO: error: conditional \"am__fastdepCXX\" was never defined.

+Usually this means the macro was only invoked conditionally." >&5

+echo "$as_me: error: conditional \"am__fastdepCXX\" was never defined.

+Usually this means the macro was only invoked conditionally." >&2;}

+   { (exit 1); exit 1; }; }

+fi

+if test -z "${GCC_TRUE}" && test -z "${GCC_FALSE}"; then

+  { { echo "$as_me:$LINENO: error: conditional \"GCC\" was never defined.

+Usually this means the macro was only invoked conditionally." >&5

+echo "$as_me: error: conditional \"GCC\" was never defined.

+Usually this means the macro was only invoked conditionally." >&2;}

+   { (exit 1); exit 1; }; }

+fi

+

+: ${CONFIG_STATUS=./config.status}

+ac_clean_files_save=$ac_clean_files

+ac_clean_files="$ac_clean_files $CONFIG_STATUS"

+{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5

+echo "$as_me: creating $CONFIG_STATUS" >&6;}

+cat >$CONFIG_STATUS <<_ACEOF

+#! $SHELL

+# Generated by $as_me.

+# Run this file to recreate the current configuration.

+# Compiler output produced by configure, useful for debugging

+# configure, is in config.log if it exists.

+

+debug=false

+ac_cs_recheck=false

+ac_cs_silent=false

+SHELL=\${CONFIG_SHELL-$SHELL}

+_ACEOF

+

+cat >>$CONFIG_STATUS <<\_ACEOF

+## --------------------- ##

+## M4sh Initialization.  ##

+## --------------------- ##

+

+# Be Bourne compatible

+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then

+  emulate sh

+  NULLCMD=:

+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which

+  # is contrary to our usage.  Disable this feature.

+  alias -g '${1+"$@"}'='"$@"'

+elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then

+  set -o posix

+fi

+DUALCASE=1; export DUALCASE # for MKS sh

+

+# Support unset when possible.

+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then

+  as_unset=unset

+else

+  as_unset=false

+fi

+

+

+# Work around bugs in pre-3.0 UWIN ksh.

+$as_unset ENV MAIL MAILPATH

+PS1='$ '

+PS2='> '

+PS4='+ '

+

+# NLS nuisances.

+for as_var in \

+  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \

+  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \

+  LC_TELEPHONE LC_TIME

+do

+  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then

+    eval $as_var=C; export $as_var

+  else

+    $as_unset $as_var

+  fi

+done

+

+# Required to use basename.

+if expr a : '\(a\)' >/dev/null 2>&1; then

+  as_expr=expr

+else

+  as_expr=false

+fi

+

+if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then

+  as_basename=basename

+else

+  as_basename=false

+fi

+

+

+# Name of the executable.

+as_me=`$as_basename "$0" ||

+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \

+	 X"$0" : 'X\(//\)$' \| \

+	 X"$0" : 'X\(/\)$' \| \

+	 .     : '\(.\)' 2>/dev/null ||

+echo X/"$0" |

+    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }

+  	  /^X\/\(\/\/\)$/{ s//\1/; q; }

+  	  /^X\/\(\/\).*/{ s//\1/; q; }

+  	  s/.*/./; q'`

+

+

+# PATH needs CR, and LINENO needs CR and PATH.

+# Avoid depending upon Character Ranges.

+as_cr_letters='abcdefghijklmnopqrstuvwxyz'

+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'

+as_cr_Letters=$as_cr_letters$as_cr_LETTERS

+as_cr_digits='0123456789'

+as_cr_alnum=$as_cr_Letters$as_cr_digits

+

+# The user is always right.

+if test "${PATH_SEPARATOR+set}" != set; then

+  echo "#! /bin/sh" >conf$$.sh

+  echo  "exit 0"   >>conf$$.sh

+  chmod +x conf$$.sh

+  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then

+    PATH_SEPARATOR=';'

+  else

+    PATH_SEPARATOR=:

+  fi

+  rm -f conf$$.sh

+fi

+

+

+  as_lineno_1=$LINENO

+  as_lineno_2=$LINENO

+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`

+  test "x$as_lineno_1" != "x$as_lineno_2" &&

+  test "x$as_lineno_3"  = "x$as_lineno_2"  || {

+  # Find who we are.  Look in the path if we contain no path at all

+  # relative or not.

+  case $0 in

+    *[\\/]* ) as_myself=$0 ;;

+    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in $PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break

+done

+

+       ;;

+  esac

+  # We did not find ourselves, most probably we were run as `sh COMMAND'

+  # in which case we are not to be found in the path.

+  if test "x$as_myself" = x; then

+    as_myself=$0

+  fi

+  if test ! -f "$as_myself"; then

+    { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5

+echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}

+   { (exit 1); exit 1; }; }

+  fi

+  case $CONFIG_SHELL in

+  '')

+    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH

+do

+  IFS=$as_save_IFS

+  test -z "$as_dir" && as_dir=.

+  for as_base in sh bash ksh sh5; do

+	 case $as_dir in

+	 /*)

+	   if ("$as_dir/$as_base" -c '

+  as_lineno_1=$LINENO

+  as_lineno_2=$LINENO

+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`

+  test "x$as_lineno_1" != "x$as_lineno_2" &&

+  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then

+	     $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }

+	     $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }

+	     CONFIG_SHELL=$as_dir/$as_base

+	     export CONFIG_SHELL

+	     exec "$CONFIG_SHELL" "$0" ${1+"$@"}

+	   fi;;

+	 esac

+       done

+done

+;;

+  esac

+

+  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO

+  # uniformly replaced by the line number.  The first 'sed' inserts a

+  # line-number line before each line; the second 'sed' does the real

+  # work.  The second script uses 'N' to pair each line-number line

+  # with the numbered line, and appends trailing '-' during

+  # substitution so that $LINENO is not a special case at line end.

+  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the

+  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)

+  sed '=' <$as_myself |

+    sed '

+      N

+      s,$,-,

+      : loop

+      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,

+      t loop

+      s,-$,,

+      s,^['$as_cr_digits']*\n,,

+    ' >$as_me.lineno &&

+  chmod +x $as_me.lineno ||

+    { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5

+echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}

+   { (exit 1); exit 1; }; }

+

+  # Don't try to exec as it changes $[0], causing all sort of problems

+  # (the dirname of $[0] is not the place where we might find the

+  # original and so on.  Autoconf is especially sensible to this).

+  . ./$as_me.lineno

+  # Exit status is that of the last command.

+  exit

+}

+

+

+case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in

+  *c*,-n*) ECHO_N= ECHO_C='

+' ECHO_T='	' ;;

+  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;

+  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;

+esac

+

+if expr a : '\(a\)' >/dev/null 2>&1; then

+  as_expr=expr

+else

+  as_expr=false

+fi

+

+rm -f conf$$ conf$$.exe conf$$.file

+echo >conf$$.file

+if ln -s conf$$.file conf$$ 2>/dev/null; then

+  # We could just check for DJGPP; but this test a) works b) is more generic

+  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).

+  if test -f conf$$.exe; then

+    # Don't use ln at all; we don't have any links

+    as_ln_s='cp -p'

+  else

+    as_ln_s='ln -s'

+  fi

+elif ln conf$$.file conf$$ 2>/dev/null; then

+  as_ln_s=ln

+else

+  as_ln_s='cp -p'

+fi

+rm -f conf$$ conf$$.exe conf$$.file

+

+if mkdir -p . 2>/dev/null; then

+  as_mkdir_p=:

+else

+  test -d ./-p && rmdir ./-p

+  as_mkdir_p=false

+fi

+

+as_executable_p="test -f"

+

+# Sed expression to map a string onto a valid CPP name.

+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"

+

+# Sed expression to map a string onto a valid variable name.

+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"

+

+

+# IFS

+# We need space, tab and new line, in precisely that order.

+as_nl='

+'

+IFS=" 	$as_nl"

+

+# CDPATH.

+$as_unset CDPATH

+

+exec 6>&1

+

+# Open the log real soon, to keep \$[0] and so on meaningful, and to

+# report actual input values of CONFIG_FILES etc. instead of their

+# values after options handling.  Logging --version etc. is OK.

+exec 5>>config.log

+{

+  echo

+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX

+## Running $as_me. ##

+_ASBOX

+} >&5

+cat >&5 <<_CSEOF

+

+This file was extended by open-vcdiff $as_me 0.1, which was

+generated by GNU Autoconf 2.59.  Invocation command line was

+

+  CONFIG_FILES    = $CONFIG_FILES

+  CONFIG_HEADERS  = $CONFIG_HEADERS

+  CONFIG_LINKS    = $CONFIG_LINKS

+  CONFIG_COMMANDS = $CONFIG_COMMANDS

+  $ $0 $@

+

+_CSEOF

+echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5

+echo >&5

+_ACEOF

+

+# Files that config.status was made for.

+if test -n "$ac_config_files"; then

+  echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS

+fi

+

+if test -n "$ac_config_headers"; then

+  echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS

+fi

+

+if test -n "$ac_config_links"; then

+  echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS

+fi

+

+if test -n "$ac_config_commands"; then

+  echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS

+fi

+

+cat >>$CONFIG_STATUS <<\_ACEOF

+

+ac_cs_usage="\

+\`$as_me' instantiates files from templates according to the

+current configuration.

+

+Usage: $0 [OPTIONS] [FILE]...

+

+  -h, --help       print this help, then exit

+  -V, --version    print version number, then exit

+  -q, --quiet      do not print progress messages

+  -d, --debug      don't remove temporary files

+      --recheck    update $as_me by reconfiguring in the same conditions

+  --file=FILE[:TEMPLATE]

+		   instantiate the configuration file FILE

+  --header=FILE[:TEMPLATE]

+		   instantiate the configuration header FILE

+

+Configuration files:

+$config_files

+

+Configuration headers:

+$config_headers

+

+Configuration commands:

+$config_commands

+

+Report bugs to <bug-autoconf@gnu.org>."

+_ACEOF

+

+cat >>$CONFIG_STATUS <<_ACEOF

+ac_cs_version="\\

+open-vcdiff config.status 0.1

+configured by $0, generated by GNU Autoconf 2.59,

+  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"

+

+Copyright (C) 2003 Free Software Foundation, Inc.

+This config.status script is free software; the Free Software Foundation

+gives unlimited permission to copy, distribute and modify it."

+srcdir=$srcdir

+INSTALL="$INSTALL"

+_ACEOF

+

+cat >>$CONFIG_STATUS <<\_ACEOF

+# If no file are specified by the user, then we need to provide default

+# value.  By we need to know if files were specified by the user.

+ac_need_defaults=:

+while test $# != 0

+do

+  case $1 in

+  --*=*)

+    ac_option=`expr "x$1" : 'x\([^=]*\)='`

+    ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`

+    ac_shift=:

+    ;;

+  -*)

+    ac_option=$1

+    ac_optarg=$2

+    ac_shift=shift

+    ;;

+  *) # This is not an option, so the user has probably given explicit

+     # arguments.

+     ac_option=$1

+     ac_need_defaults=false;;

+  esac

+

+  case $ac_option in

+  # Handling of the options.

+_ACEOF

+cat >>$CONFIG_STATUS <<\_ACEOF

+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)

+    ac_cs_recheck=: ;;

+  --version | --vers* | -V )

+    echo "$ac_cs_version"; exit 0 ;;

+  --he | --h)

+    # Conflict between --help and --header

+    { { echo "$as_me:$LINENO: error: ambiguous option: $1

+Try \`$0 --help' for more information." >&5

+echo "$as_me: error: ambiguous option: $1

+Try \`$0 --help' for more information." >&2;}

+   { (exit 1); exit 1; }; };;

+  --help | --hel | -h )

+    echo "$ac_cs_usage"; exit 0 ;;

+  --debug | --d* | -d )

+    debug=: ;;

+  --file | --fil | --fi | --f )

+    $ac_shift

+    CONFIG_FILES="$CONFIG_FILES $ac_optarg"

+    ac_need_defaults=false;;

+  --header | --heade | --head | --hea )

+    $ac_shift

+    CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"

+    ac_need_defaults=false;;

+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \

+  | -silent | --silent | --silen | --sile | --sil | --si | --s)

+    ac_cs_silent=: ;;

+

+  # This is an error.

+  -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1

+Try \`$0 --help' for more information." >&5

+echo "$as_me: error: unrecognized option: $1

+Try \`$0 --help' for more information." >&2;}

+   { (exit 1); exit 1; }; } ;;

+

+  *) ac_config_targets="$ac_config_targets $1" ;;

+

+  esac

+  shift

+done

+

+ac_configure_extra_args=

+

+if $ac_cs_silent; then

+  exec 6>/dev/null

+  ac_configure_extra_args="$ac_configure_extra_args --silent"

+fi

+

+_ACEOF

+cat >>$CONFIG_STATUS <<_ACEOF

+if \$ac_cs_recheck; then

+  echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6

+  exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion

+fi

+

+_ACEOF

+

+cat >>$CONFIG_STATUS <<_ACEOF

+#

+# INIT-COMMANDS section.

+#

+

+AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"

+

+_ACEOF

+

+

+

+cat >>$CONFIG_STATUS <<\_ACEOF

+for ac_config_target in $ac_config_targets

+do

+  case "$ac_config_target" in

+  # Handling of arguments.

+  "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;

+  "depfiles" ) CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;

+  "src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;

+  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5

+echo "$as_me: error: invalid argument: $ac_config_target" >&2;}

+   { (exit 1); exit 1; }; };;

+  esac

+done

+

+# If the user did not use the arguments to specify the items to instantiate,

+# then the envvar interface is used.  Set only those that are not.

+# We use the long form for the default assignment because of an extremely

+# bizarre bug on SunOS 4.1.3.

+if $ac_need_defaults; then

+  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files

+  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers

+  test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands

+fi

+

+# Have a temporary directory for convenience.  Make it in the build tree

+# simply because there is no reason to put it here, and in addition,

+# creating and moving files from /tmp can sometimes cause problems.

+# Create a temporary directory, and hook for its removal unless debugging.

+$debug ||

+{

+  trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0

+  trap '{ (exit 1); exit 1; }' 1 2 13 15

+}

+

+# Create a (secure) tmp directory for tmp files.

+

+{

+  tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&

+  test -n "$tmp" && test -d "$tmp"

+}  ||

+{

+  tmp=./confstat$$-$RANDOM

+  (umask 077 && mkdir $tmp)

+} ||

+{

+   echo "$me: cannot create a temporary directory in ." >&2

+   { (exit 1); exit 1; }

+}

+

+_ACEOF

+

+cat >>$CONFIG_STATUS <<_ACEOF

+

+#

+# CONFIG_FILES section.

+#

+

+# No need to generate the scripts if there are no CONFIG_FILES.

+# This happens for instance when ./config.status config.h

+if test -n "\$CONFIG_FILES"; then

+  # Protect against being on the right side of a sed subst in config.status.

+  sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;

+   s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF

+s,@SHELL@,$SHELL,;t t

+s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t

+s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t

+s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t

+s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t

+s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t

+s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t

+s,@exec_prefix@,$exec_prefix,;t t

+s,@prefix@,$prefix,;t t

+s,@program_transform_name@,$program_transform_name,;t t

+s,@bindir@,$bindir,;t t

+s,@sbindir@,$sbindir,;t t

+s,@libexecdir@,$libexecdir,;t t

+s,@datadir@,$datadir,;t t

+s,@sysconfdir@,$sysconfdir,;t t

+s,@sharedstatedir@,$sharedstatedir,;t t

+s,@localstatedir@,$localstatedir,;t t

+s,@libdir@,$libdir,;t t

+s,@includedir@,$includedir,;t t

+s,@oldincludedir@,$oldincludedir,;t t

+s,@infodir@,$infodir,;t t

+s,@mandir@,$mandir,;t t

+s,@build_alias@,$build_alias,;t t

+s,@host_alias@,$host_alias,;t t

+s,@target_alias@,$target_alias,;t t

+s,@DEFS@,$DEFS,;t t

+s,@ECHO_C@,$ECHO_C,;t t

+s,@ECHO_N@,$ECHO_N,;t t

+s,@ECHO_T@,$ECHO_T,;t t

+s,@LIBS@,$LIBS,;t t

+s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t

+s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t

+s,@INSTALL_DATA@,$INSTALL_DATA,;t t

+s,@CYGPATH_W@,$CYGPATH_W,;t t

+s,@PACKAGE@,$PACKAGE,;t t

+s,@VERSION@,$VERSION,;t t

+s,@ACLOCAL@,$ACLOCAL,;t t

+s,@AUTOCONF@,$AUTOCONF,;t t

+s,@AUTOMAKE@,$AUTOMAKE,;t t

+s,@AUTOHEADER@,$AUTOHEADER,;t t

+s,@MAKEINFO@,$MAKEINFO,;t t

+s,@install_sh@,$install_sh,;t t

+s,@STRIP@,$STRIP,;t t

+s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t

+s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t

+s,@mkdir_p@,$mkdir_p,;t t

+s,@AWK@,$AWK,;t t

+s,@SET_MAKE@,$SET_MAKE,;t t

+s,@am__leading_dot@,$am__leading_dot,;t t

+s,@AMTAR@,$AMTAR,;t t

+s,@am__tar@,$am__tar,;t t

+s,@am__untar@,$am__untar,;t t

+s,@CC@,$CC,;t t

+s,@CFLAGS@,$CFLAGS,;t t

+s,@LDFLAGS@,$LDFLAGS,;t t

+s,@CPPFLAGS@,$CPPFLAGS,;t t

+s,@ac_ct_CC@,$ac_ct_CC,;t t

+s,@EXEEXT@,$EXEEXT,;t t

+s,@OBJEXT@,$OBJEXT,;t t

+s,@DEPDIR@,$DEPDIR,;t t

+s,@am__include@,$am__include,;t t

+s,@am__quote@,$am__quote,;t t

+s,@AMDEP_TRUE@,$AMDEP_TRUE,;t t

+s,@AMDEP_FALSE@,$AMDEP_FALSE,;t t

+s,@AMDEPBACKSLASH@,$AMDEPBACKSLASH,;t t

+s,@CCDEPMODE@,$CCDEPMODE,;t t

+s,@am__fastdepCC_TRUE@,$am__fastdepCC_TRUE,;t t

+s,@am__fastdepCC_FALSE@,$am__fastdepCC_FALSE,;t t

+s,@CPP@,$CPP,;t t

+s,@CXX@,$CXX,;t t

+s,@CXXFLAGS@,$CXXFLAGS,;t t

+s,@ac_ct_CXX@,$ac_ct_CXX,;t t

+s,@CXXDEPMODE@,$CXXDEPMODE,;t t

+s,@am__fastdepCXX_TRUE@,$am__fastdepCXX_TRUE,;t t

+s,@am__fastdepCXX_FALSE@,$am__fastdepCXX_FALSE,;t t

+s,@GCC_TRUE@,$GCC_TRUE,;t t

+s,@GCC_FALSE@,$GCC_FALSE,;t t

+s,@build@,$build,;t t

+s,@build_cpu@,$build_cpu,;t t

+s,@build_vendor@,$build_vendor,;t t

+s,@build_os@,$build_os,;t t

+s,@host@,$host,;t t

+s,@host_cpu@,$host_cpu,;t t

+s,@host_vendor@,$host_vendor,;t t

+s,@host_os@,$host_os,;t t

+s,@EGREP@,$EGREP,;t t

+s,@LN_S@,$LN_S,;t t

+s,@ECHO@,$ECHO,;t t

+s,@AR@,$AR,;t t

+s,@ac_ct_AR@,$ac_ct_AR,;t t

+s,@RANLIB@,$RANLIB,;t t

+s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t

+s,@CXXCPP@,$CXXCPP,;t t

+s,@F77@,$F77,;t t

+s,@FFLAGS@,$FFLAGS,;t t

+s,@ac_ct_F77@,$ac_ct_F77,;t t

+s,@LIBTOOL@,$LIBTOOL,;t t

+s,@LIBTOOL_DEPS@,$LIBTOOL_DEPS,;t t

+s,@acx_pthread_config@,$acx_pthread_config,;t t

+s,@PTHREAD_CC@,$PTHREAD_CC,;t t

+s,@PTHREAD_LIBS@,$PTHREAD_LIBS,;t t

+s,@PTHREAD_CFLAGS@,$PTHREAD_CFLAGS,;t t

+s,@LIBOBJS@,$LIBOBJS,;t t

+s,@LTLIBOBJS@,$LTLIBOBJS,;t t

+CEOF

+

+_ACEOF

+

+  cat >>$CONFIG_STATUS <<\_ACEOF

+  # Split the substitutions into bite-sized pieces for seds with

+  # small command number limits, like on Digital OSF/1 and HP-UX.

+  ac_max_sed_lines=48

+  ac_sed_frag=1 # Number of current file.

+  ac_beg=1 # First line for current file.

+  ac_end=$ac_max_sed_lines # Line after last line for current file.

+  ac_more_lines=:

+  ac_sed_cmds=

+  while $ac_more_lines; do

+    if test $ac_beg -gt 1; then

+      sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag

+    else

+      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag

+    fi

+    if test ! -s $tmp/subs.frag; then

+      ac_more_lines=false

+    else

+      # The purpose of the label and of the branching condition is to

+      # speed up the sed processing (if there are no `@' at all, there

+      # is no need to browse any of the substitutions).

+      # These are the two extra sed commands mentioned above.

+      (echo ':t

+  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed

+      if test -z "$ac_sed_cmds"; then

+	ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"

+      else

+	ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"

+      fi

+      ac_sed_frag=`expr $ac_sed_frag + 1`

+      ac_beg=$ac_end

+      ac_end=`expr $ac_end + $ac_max_sed_lines`

+    fi

+  done

+  if test -z "$ac_sed_cmds"; then

+    ac_sed_cmds=cat

+  fi

+fi # test -n "$CONFIG_FILES"

+

+_ACEOF

+cat >>$CONFIG_STATUS <<\_ACEOF

+for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue

+  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".

+  case $ac_file in

+  - | *:- | *:-:* ) # input from stdin

+	cat >$tmp/stdin

+	ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`

+	ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;

+  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`

+	ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;

+  * )   ac_file_in=$ac_file.in ;;

+  esac

+

+  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.

+  ac_dir=`(dirname "$ac_file") 2>/dev/null ||

+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \

+	 X"$ac_file" : 'X\(//\)[^/]' \| \

+	 X"$ac_file" : 'X\(//\)$' \| \

+	 X"$ac_file" : 'X\(/\)' \| \

+	 .     : '\(.\)' 2>/dev/null ||

+echo X"$ac_file" |

+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }

+  	  /^X\(\/\/\)$/{ s//\1/; q; }

+  	  /^X\(\/\).*/{ s//\1/; q; }

+  	  s/.*/./; q'`

+  { if $as_mkdir_p; then

+    mkdir -p "$ac_dir"

+  else

+    as_dir="$ac_dir"

+    as_dirs=

+    while test ! -d "$as_dir"; do

+      as_dirs="$as_dir $as_dirs"

+      as_dir=`(dirname "$as_dir") 2>/dev/null ||

+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \

+	 X"$as_dir" : 'X\(//\)[^/]' \| \

+	 X"$as_dir" : 'X\(//\)$' \| \

+	 X"$as_dir" : 'X\(/\)' \| \

+	 .     : '\(.\)' 2>/dev/null ||

+echo X"$as_dir" |

+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }

+  	  /^X\(\/\/\)$/{ s//\1/; q; }

+  	  /^X\(\/\).*/{ s//\1/; q; }

+  	  s/.*/./; q'`

+    done

+    test ! -n "$as_dirs" || mkdir $as_dirs

+  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5

+echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}

+   { (exit 1); exit 1; }; }; }

+

+  ac_builddir=.

+

+if test "$ac_dir" != .; then

+  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`

+  # A "../" for each directory in $ac_dir_suffix.

+  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`

+else

+  ac_dir_suffix= ac_top_builddir=

+fi

+

+case $srcdir in

+  .)  # No --srcdir option.  We are building in place.

+    ac_srcdir=.

+    if test -z "$ac_top_builddir"; then

+       ac_top_srcdir=.

+    else

+       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`

+    fi ;;

+  [\\/]* | ?:[\\/]* )  # Absolute path.

+    ac_srcdir=$srcdir$ac_dir_suffix;

+    ac_top_srcdir=$srcdir ;;

+  *) # Relative path.

+    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix

+    ac_top_srcdir=$ac_top_builddir$srcdir ;;

+esac

+

+# Do not use `cd foo && pwd` to compute absolute paths, because

+# the directories may not exist.

+case `pwd` in

+.) ac_abs_builddir="$ac_dir";;

+*)

+  case "$ac_dir" in

+  .) ac_abs_builddir=`pwd`;;

+  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;

+  *) ac_abs_builddir=`pwd`/"$ac_dir";;

+  esac;;

+esac

+case $ac_abs_builddir in

+.) ac_abs_top_builddir=${ac_top_builddir}.;;

+*)

+  case ${ac_top_builddir}. in

+  .) ac_abs_top_builddir=$ac_abs_builddir;;

+  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;

+  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;

+  esac;;

+esac

+case $ac_abs_builddir in

+.) ac_abs_srcdir=$ac_srcdir;;

+*)

+  case $ac_srcdir in

+  .) ac_abs_srcdir=$ac_abs_builddir;;

+  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;

+  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;

+  esac;;

+esac

+case $ac_abs_builddir in

+.) ac_abs_top_srcdir=$ac_top_srcdir;;

+*)

+  case $ac_top_srcdir in

+  .) ac_abs_top_srcdir=$ac_abs_builddir;;

+  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;

+  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;

+  esac;;

+esac

+

+

+  case $INSTALL in

+  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;

+  *) ac_INSTALL=$ac_top_builddir$INSTALL ;;

+  esac

+

+  # Let's still pretend it is `configure' which instantiates (i.e., don't

+  # use $as_me), people would be surprised to read:

+  #    /* config.h.  Generated by config.status.  */

+  if test x"$ac_file" = x-; then

+    configure_input=

+  else

+    configure_input="$ac_file.  "

+  fi

+  configure_input=$configure_input"Generated from `echo $ac_file_in |

+				     sed 's,.*/,,'` by configure."

+

+  # First look for the input files in the build tree, otherwise in the

+  # src tree.

+  ac_file_inputs=`IFS=:

+    for f in $ac_file_in; do

+      case $f in

+      -) echo $tmp/stdin ;;

+      [\\/$]*)

+	 # Absolute (can't be DOS-style, as IFS=:)

+	 test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5

+echo "$as_me: error: cannot find input file: $f" >&2;}

+   { (exit 1); exit 1; }; }

+	 echo "$f";;

+      *) # Relative

+	 if test -f "$f"; then

+	   # Build tree

+	   echo "$f"

+	 elif test -f "$srcdir/$f"; then

+	   # Source tree

+	   echo "$srcdir/$f"

+	 else

+	   # /dev/null tree

+	   { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5

+echo "$as_me: error: cannot find input file: $f" >&2;}

+   { (exit 1); exit 1; }; }

+	 fi;;

+      esac

+    done` || { (exit 1); exit 1; }

+

+  if test x"$ac_file" != x-; then

+    { echo "$as_me:$LINENO: creating $ac_file" >&5

+echo "$as_me: creating $ac_file" >&6;}

+    rm -f "$ac_file"

+  fi

+_ACEOF

+cat >>$CONFIG_STATUS <<_ACEOF

+  sed "$ac_vpsub

+$extrasub

+_ACEOF

+cat >>$CONFIG_STATUS <<\_ACEOF

+:t

+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b

+s,@configure_input@,$configure_input,;t t

+s,@srcdir@,$ac_srcdir,;t t

+s,@abs_srcdir@,$ac_abs_srcdir,;t t

+s,@top_srcdir@,$ac_top_srcdir,;t t

+s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t

+s,@builddir@,$ac_builddir,;t t

+s,@abs_builddir@,$ac_abs_builddir,;t t

+s,@top_builddir@,$ac_top_builddir,;t t

+s,@abs_top_builddir@,$ac_abs_top_builddir,;t t

+s,@INSTALL@,$ac_INSTALL,;t t

+" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out

+  rm -f $tmp/stdin

+  if test x"$ac_file" != x-; then

+    mv $tmp/out $ac_file

+  else

+    cat $tmp/out

+    rm -f $tmp/out

+  fi

+

+done

+_ACEOF

+cat >>$CONFIG_STATUS <<\_ACEOF

+

+#

+# CONFIG_HEADER section.

+#

+

+# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where

+# NAME is the cpp macro being defined and VALUE is the value it is being given.

+#

+# ac_d sets the value in "#define NAME VALUE" lines.

+ac_dA='s,^\([	 ]*\)#\([	 ]*define[	 ][	 ]*\)'

+ac_dB='[	 ].*$,\1#\2'

+ac_dC=' '

+ac_dD=',;t'

+# ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".

+ac_uA='s,^\([	 ]*\)#\([	 ]*\)undef\([	 ][	 ]*\)'

+ac_uB='$,\1#\2define\3'

+ac_uC=' '

+ac_uD=',;t'

+

+for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue

+  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".

+  case $ac_file in

+  - | *:- | *:-:* ) # input from stdin

+	cat >$tmp/stdin

+	ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`

+	ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;

+  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`

+	ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;

+  * )   ac_file_in=$ac_file.in ;;

+  esac

+

+  test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5

+echo "$as_me: creating $ac_file" >&6;}

+

+  # First look for the input files in the build tree, otherwise in the

+  # src tree.

+  ac_file_inputs=`IFS=:

+    for f in $ac_file_in; do

+      case $f in

+      -) echo $tmp/stdin ;;

+      [\\/$]*)

+	 # Absolute (can't be DOS-style, as IFS=:)

+	 test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5

+echo "$as_me: error: cannot find input file: $f" >&2;}

+   { (exit 1); exit 1; }; }

+	 # Do quote $f, to prevent DOS paths from being IFS'd.

+	 echo "$f";;

+      *) # Relative

+	 if test -f "$f"; then

+	   # Build tree

+	   echo "$f"

+	 elif test -f "$srcdir/$f"; then

+	   # Source tree

+	   echo "$srcdir/$f"

+	 else

+	   # /dev/null tree

+	   { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5

+echo "$as_me: error: cannot find input file: $f" >&2;}

+   { (exit 1); exit 1; }; }

+	 fi;;

+      esac

+    done` || { (exit 1); exit 1; }

+  # Remove the trailing spaces.

+  sed 's/[	 ]*$//' $ac_file_inputs >$tmp/in

+

+_ACEOF

+

+# Transform confdefs.h into two sed scripts, `conftest.defines' and

+# `conftest.undefs', that substitutes the proper values into

+# config.h.in to produce config.h.  The first handles `#define'

+# templates, and the second `#undef' templates.

+# And first: Protect against being on the right side of a sed subst in

+# config.status.  Protect against being in an unquoted here document

+# in config.status.

+rm -f conftest.defines conftest.undefs

+# Using a here document instead of a string reduces the quoting nightmare.

+# Putting comments in sed scripts is not portable.

+#

+# `end' is used to avoid that the second main sed command (meant for

+# 0-ary CPP macros) applies to n-ary macro definitions.

+# See the Autoconf documentation for `clear'.

+cat >confdef2sed.sed <<\_ACEOF

+s/[\\&,]/\\&/g

+s,[\\$`],\\&,g

+t clear

+: clear

+s,^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 (][^	 (]*\)\(([^)]*)\)[	 ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp

+t end

+s,^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 ][^	 ]*\)[	 ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp

+: end

+_ACEOF

+# If some macros were called several times there might be several times

+# the same #defines, which is useless.  Nevertheless, we may not want to

+# sort them, since we want the *last* AC-DEFINE to be honored.

+uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines

+sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs

+rm -f confdef2sed.sed

+

+# This sed command replaces #undef with comments.  This is necessary, for

+# example, in the case of _POSIX_SOURCE, which is predefined and required

+# on some systems where configure will not decide to define it.

+cat >>conftest.undefs <<\_ACEOF

+s,^[	 ]*#[	 ]*undef[	 ][	 ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,

+_ACEOF

+

+# Break up conftest.defines because some shells have a limit on the size

+# of here documents, and old seds have small limits too (100 cmds).

+echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS

+echo '  if grep "^[	 ]*#[	 ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS

+echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS

+echo '  :' >>$CONFIG_STATUS

+rm -f conftest.tail

+while grep . conftest.defines >/dev/null

+do

+  # Write a limited-size here document to $tmp/defines.sed.

+  echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS

+  # Speed up: don't consider the non `#define' lines.

+  echo '/^[	 ]*#[	 ]*define/!b' >>$CONFIG_STATUS

+  # Work around the forget-to-reset-the-flag bug.

+  echo 't clr' >>$CONFIG_STATUS

+  echo ': clr' >>$CONFIG_STATUS

+  sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS

+  echo 'CEOF

+  sed -f $tmp/defines.sed $tmp/in >$tmp/out

+  rm -f $tmp/in

+  mv $tmp/out $tmp/in

+' >>$CONFIG_STATUS

+  sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail

+  rm -f conftest.defines

+  mv conftest.tail conftest.defines

+done

+rm -f conftest.defines

+echo '  fi # grep' >>$CONFIG_STATUS

+echo >>$CONFIG_STATUS

+

+# Break up conftest.undefs because some shells have a limit on the size

+# of here documents, and old seds have small limits too (100 cmds).

+echo '  # Handle all the #undef templates' >>$CONFIG_STATUS

+rm -f conftest.tail

+while grep . conftest.undefs >/dev/null

+do

+  # Write a limited-size here document to $tmp/undefs.sed.

+  echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS

+  # Speed up: don't consider the non `#undef'

+  echo '/^[	 ]*#[	 ]*undef/!b' >>$CONFIG_STATUS

+  # Work around the forget-to-reset-the-flag bug.

+  echo 't clr' >>$CONFIG_STATUS

+  echo ': clr' >>$CONFIG_STATUS

+  sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS

+  echo 'CEOF

+  sed -f $tmp/undefs.sed $tmp/in >$tmp/out

+  rm -f $tmp/in

+  mv $tmp/out $tmp/in

+' >>$CONFIG_STATUS

+  sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail

+  rm -f conftest.undefs

+  mv conftest.tail conftest.undefs

+done

+rm -f conftest.undefs

+

+cat >>$CONFIG_STATUS <<\_ACEOF

+  # Let's still pretend it is `configure' which instantiates (i.e., don't

+  # use $as_me), people would be surprised to read:

+  #    /* config.h.  Generated by config.status.  */

+  if test x"$ac_file" = x-; then

+    echo "/* Generated by configure.  */" >$tmp/config.h

+  else

+    echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h

+  fi

+  cat $tmp/in >>$tmp/config.h

+  rm -f $tmp/in

+  if test x"$ac_file" != x-; then

+    if diff $ac_file $tmp/config.h >/dev/null 2>&1; then

+      { echo "$as_me:$LINENO: $ac_file is unchanged" >&5

+echo "$as_me: $ac_file is unchanged" >&6;}

+    else

+      ac_dir=`(dirname "$ac_file") 2>/dev/null ||

+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \

+	 X"$ac_file" : 'X\(//\)[^/]' \| \

+	 X"$ac_file" : 'X\(//\)$' \| \

+	 X"$ac_file" : 'X\(/\)' \| \

+	 .     : '\(.\)' 2>/dev/null ||

+echo X"$ac_file" |

+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }

+  	  /^X\(\/\/\)$/{ s//\1/; q; }

+  	  /^X\(\/\).*/{ s//\1/; q; }

+  	  s/.*/./; q'`

+      { if $as_mkdir_p; then

+    mkdir -p "$ac_dir"

+  else

+    as_dir="$ac_dir"

+    as_dirs=

+    while test ! -d "$as_dir"; do

+      as_dirs="$as_dir $as_dirs"

+      as_dir=`(dirname "$as_dir") 2>/dev/null ||

+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \

+	 X"$as_dir" : 'X\(//\)[^/]' \| \

+	 X"$as_dir" : 'X\(//\)$' \| \

+	 X"$as_dir" : 'X\(/\)' \| \

+	 .     : '\(.\)' 2>/dev/null ||

+echo X"$as_dir" |

+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }

+  	  /^X\(\/\/\)$/{ s//\1/; q; }

+  	  /^X\(\/\).*/{ s//\1/; q; }

+  	  s/.*/./; q'`

+    done

+    test ! -n "$as_dirs" || mkdir $as_dirs

+  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5

+echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}

+   { (exit 1); exit 1; }; }; }

+

+      rm -f $ac_file

+      mv $tmp/config.h $ac_file

+    fi

+  else

+    cat $tmp/config.h

+    rm -f $tmp/config.h

+  fi

+# Compute $ac_file's index in $config_headers.

+_am_stamp_count=1

+for _am_header in $config_headers :; do

+  case $_am_header in

+    $ac_file | $ac_file:* )

+      break ;;

+    * )

+      _am_stamp_count=`expr $_am_stamp_count + 1` ;;

+  esac

+done

+echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||

+$as_expr X$ac_file : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \

+	 X$ac_file : 'X\(//\)[^/]' \| \

+	 X$ac_file : 'X\(//\)$' \| \

+	 X$ac_file : 'X\(/\)' \| \

+	 .     : '\(.\)' 2>/dev/null ||

+echo X$ac_file |

+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }

+  	  /^X\(\/\/\)$/{ s//\1/; q; }

+  	  /^X\(\/\).*/{ s//\1/; q; }

+  	  s/.*/./; q'`/stamp-h$_am_stamp_count

+done

+_ACEOF

+cat >>$CONFIG_STATUS <<\_ACEOF

+

+#

+# CONFIG_COMMANDS section.

+#

+for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue

+  ac_dest=`echo "$ac_file" | sed 's,:.*,,'`

+  ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`

+  ac_dir=`(dirname "$ac_dest") 2>/dev/null ||

+$as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \

+	 X"$ac_dest" : 'X\(//\)[^/]' \| \

+	 X"$ac_dest" : 'X\(//\)$' \| \

+	 X"$ac_dest" : 'X\(/\)' \| \

+	 .     : '\(.\)' 2>/dev/null ||

+echo X"$ac_dest" |

+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }

+  	  /^X\(\/\/\)$/{ s//\1/; q; }

+  	  /^X\(\/\).*/{ s//\1/; q; }

+  	  s/.*/./; q'`

+  { if $as_mkdir_p; then

+    mkdir -p "$ac_dir"

+  else

+    as_dir="$ac_dir"

+    as_dirs=

+    while test ! -d "$as_dir"; do

+      as_dirs="$as_dir $as_dirs"

+      as_dir=`(dirname "$as_dir") 2>/dev/null ||

+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \

+	 X"$as_dir" : 'X\(//\)[^/]' \| \

+	 X"$as_dir" : 'X\(//\)$' \| \

+	 X"$as_dir" : 'X\(/\)' \| \

+	 .     : '\(.\)' 2>/dev/null ||

+echo X"$as_dir" |

+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }

+  	  /^X\(\/\/\)$/{ s//\1/; q; }

+  	  /^X\(\/\).*/{ s//\1/; q; }

+  	  s/.*/./; q'`

+    done

+    test ! -n "$as_dirs" || mkdir $as_dirs

+  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5

+echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}

+   { (exit 1); exit 1; }; }; }

+

+  ac_builddir=.

+

+if test "$ac_dir" != .; then

+  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`

+  # A "../" for each directory in $ac_dir_suffix.

+  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`

+else

+  ac_dir_suffix= ac_top_builddir=

+fi

+

+case $srcdir in

+  .)  # No --srcdir option.  We are building in place.

+    ac_srcdir=.

+    if test -z "$ac_top_builddir"; then

+       ac_top_srcdir=.

+    else

+       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`

+    fi ;;

+  [\\/]* | ?:[\\/]* )  # Absolute path.

+    ac_srcdir=$srcdir$ac_dir_suffix;

+    ac_top_srcdir=$srcdir ;;

+  *) # Relative path.

+    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix

+    ac_top_srcdir=$ac_top_builddir$srcdir ;;

+esac

+

+# Do not use `cd foo && pwd` to compute absolute paths, because

+# the directories may not exist.

+case `pwd` in

+.) ac_abs_builddir="$ac_dir";;

+*)

+  case "$ac_dir" in

+  .) ac_abs_builddir=`pwd`;;

+  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;

+  *) ac_abs_builddir=`pwd`/"$ac_dir";;

+  esac;;

+esac

+case $ac_abs_builddir in

+.) ac_abs_top_builddir=${ac_top_builddir}.;;

+*)

+  case ${ac_top_builddir}. in

+  .) ac_abs_top_builddir=$ac_abs_builddir;;

+  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;

+  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;

+  esac;;

+esac

+case $ac_abs_builddir in

+.) ac_abs_srcdir=$ac_srcdir;;

+*)

+  case $ac_srcdir in

+  .) ac_abs_srcdir=$ac_abs_builddir;;

+  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;

+  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;

+  esac;;

+esac

+case $ac_abs_builddir in

+.) ac_abs_top_srcdir=$ac_top_srcdir;;

+*)

+  case $ac_top_srcdir in

+  .) ac_abs_top_srcdir=$ac_abs_builddir;;

+  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;

+  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;

+  esac;;

+esac

+

+

+  { echo "$as_me:$LINENO: executing $ac_dest commands" >&5

+echo "$as_me: executing $ac_dest commands" >&6;}

+  case $ac_dest in

+    depfiles ) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do

+  # Strip MF so we end up with the name of the file.

+  mf=`echo "$mf" | sed -e 's/:.*$//'`

+  # Check whether this is an Automake generated Makefile or not.

+  # We used to match only the files named `Makefile.in', but

+  # some people rename them; so instead we look at the file content.

+  # Grep'ing the first line is not enough: some people post-process

+  # each Makefile.in and add a new line on top of each file to say so.

+  # So let's grep whole file.

+  if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then

+    dirpart=`(dirname "$mf") 2>/dev/null ||

+$as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \

+	 X"$mf" : 'X\(//\)[^/]' \| \

+	 X"$mf" : 'X\(//\)$' \| \

+	 X"$mf" : 'X\(/\)' \| \

+	 .     : '\(.\)' 2>/dev/null ||

+echo X"$mf" |

+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }

+  	  /^X\(\/\/\)$/{ s//\1/; q; }

+  	  /^X\(\/\).*/{ s//\1/; q; }

+  	  s/.*/./; q'`

+  else

+    continue

+  fi

+  # Extract the definition of DEPDIR, am__include, and am__quote

+  # from the Makefile without running `make'.

+  DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`

+  test -z "$DEPDIR" && continue

+  am__include=`sed -n 's/^am__include = //p' < "$mf"`

+  test -z "am__include" && continue

+  am__quote=`sed -n 's/^am__quote = //p' < "$mf"`

+  # When using ansi2knr, U may be empty or an underscore; expand it

+  U=`sed -n 's/^U = //p' < "$mf"`

+  # Find all dependency output files, they are included files with

+  # $(DEPDIR) in their names.  We invoke sed twice because it is the

+  # simplest approach to changing $(DEPDIR) to its actual value in the

+  # expansion.

+  for file in `sed -n "

+    s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \

+       sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do

+    # Make sure the directory exists.

+    test -f "$dirpart/$file" && continue

+    fdir=`(dirname "$file") 2>/dev/null ||

+$as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \

+	 X"$file" : 'X\(//\)[^/]' \| \

+	 X"$file" : 'X\(//\)$' \| \

+	 X"$file" : 'X\(/\)' \| \

+	 .     : '\(.\)' 2>/dev/null ||

+echo X"$file" |

+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }

+  	  /^X\(\/\/\)$/{ s//\1/; q; }

+  	  /^X\(\/\).*/{ s//\1/; q; }

+  	  s/.*/./; q'`

+    { if $as_mkdir_p; then

+    mkdir -p $dirpart/$fdir

+  else

+    as_dir=$dirpart/$fdir

+    as_dirs=

+    while test ! -d "$as_dir"; do

+      as_dirs="$as_dir $as_dirs"

+      as_dir=`(dirname "$as_dir") 2>/dev/null ||

+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \

+	 X"$as_dir" : 'X\(//\)[^/]' \| \

+	 X"$as_dir" : 'X\(//\)$' \| \

+	 X"$as_dir" : 'X\(/\)' \| \

+	 .     : '\(.\)' 2>/dev/null ||

+echo X"$as_dir" |

+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }

+  	  /^X\(\/\/\)$/{ s//\1/; q; }

+  	  /^X\(\/\).*/{ s//\1/; q; }

+  	  s/.*/./; q'`

+    done

+    test ! -n "$as_dirs" || mkdir $as_dirs

+  fi || { { echo "$as_me:$LINENO: error: cannot create directory $dirpart/$fdir" >&5

+echo "$as_me: error: cannot create directory $dirpart/$fdir" >&2;}

+   { (exit 1); exit 1; }; }; }

+

+    # echo "creating $dirpart/$file"

+    echo '# dummy' > "$dirpart/$file"

+  done

+done

+ ;;

+  esac

+done

+_ACEOF

+

+cat >>$CONFIG_STATUS <<\_ACEOF

+

+{ (exit 0); exit 0; }

+_ACEOF

+chmod +x $CONFIG_STATUS

+ac_clean_files=$ac_clean_files_save

+

+

+# configure is writing to config.log, and then calls config.status.

+# config.status does its own redirection, appending to config.log.

+# Unfortunately, on DOS this fails, as config.log is still kept open

+# by configure, so config.status won't be able to write to it; its

+# output is simply discarded.  So we exec the FD to /dev/null,

+# effectively closing config.log, so it can be properly (re)opened and

+# appended to by config.status.  When coming back to configure, we

+# need to make the FD available again.

+if test "$no_create" != yes; then

+  ac_cs_success=:

+  ac_config_status_args=

+  test "$silent" = yes &&

+    ac_config_status_args="$ac_config_status_args --quiet"

+  exec 5>/dev/null

+  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false

+  exec 5>>config.log

+  # Use ||, not &&, to avoid exiting from the if with $? = 1, which

+  # would make configure fail if this is the last instruction.

+  $ac_cs_success || { (exit 1); exit 1; }

+fi

+

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/configure.ac b/sdch/open_vcdiff/depot/opensource/open-vcdiff/configure.ac
new file mode 100644
index 0000000..fd93fae
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/configure.ac
@@ -0,0 +1,51 @@
+## Process this file with autoconf to produce configure.

+## In general, the safest way to proceed is to run ./autogen.sh

+

+# make sure we're interpreted by some minimal autoconf

+AC_PREREQ(2.57)

+

+AC_INIT(open-vcdiff, 0.1, opensource@google.com)

+AC_CONFIG_SRCDIR(README)

+AM_INIT_AUTOMAKE

+AM_CONFIG_HEADER(src/config.h)

+

+# Checks for programs.

+AC_PROG_CC

+AC_PROG_CPP

+AC_PROG_CXX

+AM_CONDITIONAL(GCC, test "$GCC" = yes)   # let the Makefile know if we're gcc

+

+AC_PROG_LIBTOOL

+AC_SUBST(LIBTOOL_DEPS)

+

+# Check whether some low-level functions/files are available

+AC_HEADER_STDC

+

+AC_CHECK_HEADERS([ext/rope])

+AC_CHECK_HEADERS([getopt.h])

+AC_CHECK_HEADERS([malloc.h])

+AC_CHECK_HEADERS([sys/mman.h])

+AC_CHECK_HEADERS([sys/time.h])

+AC_CHECK_HEADERS([unistd.h])

+AC_CHECK_HEADERS([windows.h])

+AC_CHECK_FUNCS([gettimeofday QueryPerformanceCounter])

+AC_CHECK_FUNCS([memalign posix_memalign])

+AC_CHECK_FUNCS([mprotect])

+

+# Start of definitions needed by gflags package

+

+AC_CHECK_HEADERS([stdint.h sys/types.h inttypes.h])

+AC_CHECK_HEADERS([fnmatch.h])

+AC_CHECK_FUNCS([InitializeCriticalSection])

+AC_CHECK_FUNCS([InterlockedCompareExchange])

+AC_CHECK_FUNCS([strtoll strtoq])

+AC_CHECK_TYPES([uint16_t, u_int16_t, __int16])

+

+AX_C___ATTRIBUTE__

+

+ACX_PTHREAD

+

+# End of definitions needed by gflags package

+

+AC_CONFIG_FILES([Makefile])

+AC_OUTPUT

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/depcomp b/sdch/open_vcdiff/depot/opensource/open-vcdiff/depcomp
new file mode 100644
index 0000000..3c86718
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/depcomp
@@ -0,0 +1,530 @@
+#! /bin/sh

+# depcomp - compile a program generating dependencies as side-effects

+

+scriptversion=2005-07-09.11

+

+# Copyright (C) 1999, 2000, 2003, 2004, 2005 Free Software Foundation, Inc.

+

+# This program is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published by

+# the Free Software Foundation; either version 2, or (at your option)

+# any later version.

+

+# This program is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+# GNU General Public License for more details.

+

+# You should have received a copy of the GNU General Public License

+# along with this program; if not, write to the Free Software

+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

+# 02110-1301, USA.

+

+# As a special exception to the GNU General Public License, if you

+# distribute this file as part of a program that contains a

+# configuration script generated by Autoconf, you may include it under

+# the same distribution terms that you use for the rest of that program.

+

+# Originally written by Alexandre Oliva <oliva@dcc.unicamp.br>.

+

+case $1 in

+  '')

+     echo "$0: No command.  Try \`$0 --help' for more information." 1>&2

+     exit 1;

+     ;;

+  -h | --h*)

+    cat <<\EOF

+Usage: depcomp [--help] [--version] PROGRAM [ARGS]

+

+Run PROGRAMS ARGS to compile a file, generating dependencies

+as side-effects.

+

+Environment variables:

+  depmode     Dependency tracking mode.

+  source      Source file read by `PROGRAMS ARGS'.

+  object      Object file output by `PROGRAMS ARGS'.

+  DEPDIR      directory where to store dependencies.

+  depfile     Dependency file to output.

+  tmpdepfile  Temporary file to use when outputing dependencies.

+  libtool     Whether libtool is used (yes/no).

+

+Report bugs to <bug-automake@gnu.org>.

+EOF

+    exit $?

+    ;;

+  -v | --v*)

+    echo "depcomp $scriptversion"

+    exit $?

+    ;;

+esac

+

+if test -z "$depmode" || test -z "$source" || test -z "$object"; then

+  echo "depcomp: Variables source, object and depmode must be set" 1>&2

+  exit 1

+fi

+

+# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.

+depfile=${depfile-`echo "$object" |

+  sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}

+tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}

+

+rm -f "$tmpdepfile"

+

+# Some modes work just like other modes, but use different flags.  We

+# parameterize here, but still list the modes in the big case below,

+# to make depend.m4 easier to write.  Note that we *cannot* use a case

+# here, because this file can only contain one case statement.

+if test "$depmode" = hp; then

+  # HP compiler uses -M and no extra arg.

+  gccflag=-M

+  depmode=gcc

+fi

+

+if test "$depmode" = dashXmstdout; then

+   # This is just like dashmstdout with a different argument.

+   dashmflag=-xM

+   depmode=dashmstdout

+fi

+

+case "$depmode" in

+gcc3)

+## gcc 3 implements dependency tracking that does exactly what

+## we want.  Yay!  Note: for some reason libtool 1.4 doesn't like

+## it if -MD -MP comes after the -MF stuff.  Hmm.

+  "$@" -MT "$object" -MD -MP -MF "$tmpdepfile"

+  stat=$?

+  if test $stat -eq 0; then :

+  else

+    rm -f "$tmpdepfile"

+    exit $stat

+  fi

+  mv "$tmpdepfile" "$depfile"

+  ;;

+

+gcc)

+## There are various ways to get dependency output from gcc.  Here's

+## why we pick this rather obscure method:

+## - Don't want to use -MD because we'd like the dependencies to end

+##   up in a subdir.  Having to rename by hand is ugly.

+##   (We might end up doing this anyway to support other compilers.)

+## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like

+##   -MM, not -M (despite what the docs say).

+## - Using -M directly means running the compiler twice (even worse

+##   than renaming).

+  if test -z "$gccflag"; then

+    gccflag=-MD,

+  fi

+  "$@" -Wp,"$gccflag$tmpdepfile"

+  stat=$?

+  if test $stat -eq 0; then :

+  else

+    rm -f "$tmpdepfile"

+    exit $stat

+  fi

+  rm -f "$depfile"

+  echo "$object : \\" > "$depfile"

+  alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

+## The second -e expression handles DOS-style file names with drive letters.

+  sed -e 's/^[^:]*: / /' \

+      -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"

+## This next piece of magic avoids the `deleted header file' problem.

+## The problem is that when a header file which appears in a .P file

+## is deleted, the dependency causes make to die (because there is

+## typically no way to rebuild the header).  We avoid this by adding

+## dummy dependencies for each header file.  Too bad gcc doesn't do

+## this for us directly.

+  tr ' ' '

+' < "$tmpdepfile" |

+## Some versions of gcc put a space before the `:'.  On the theory

+## that the space means something, we add a space to the output as

+## well.

+## Some versions of the HPUX 10.20 sed can't process this invocation

+## correctly.  Breaking it into two sed invocations is a workaround.

+    sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"

+  rm -f "$tmpdepfile"

+  ;;

+

+hp)

+  # This case exists only to let depend.m4 do its work.  It works by

+  # looking at the text of this script.  This case will never be run,

+  # since it is checked for above.

+  exit 1

+  ;;

+

+sgi)

+  if test "$libtool" = yes; then

+    "$@" "-Wp,-MDupdate,$tmpdepfile"

+  else

+    "$@" -MDupdate "$tmpdepfile"

+  fi

+  stat=$?

+  if test $stat -eq 0; then :

+  else

+    rm -f "$tmpdepfile"

+    exit $stat

+  fi

+  rm -f "$depfile"

+

+  if test -f "$tmpdepfile"; then  # yes, the sourcefile depend on other files

+    echo "$object : \\" > "$depfile"

+

+    # Clip off the initial element (the dependent).  Don't try to be

+    # clever and replace this with sed code, as IRIX sed won't handle

+    # lines with more than a fixed number of characters (4096 in

+    # IRIX 6.2 sed, 8192 in IRIX 6.5).  We also remove comment lines;

+    # the IRIX cc adds comments like `#:fec' to the end of the

+    # dependency line.

+    tr ' ' '

+' < "$tmpdepfile" \

+    | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \

+    tr '

+' ' ' >> $depfile

+    echo >> $depfile

+

+    # The second pass generates a dummy entry for each header file.

+    tr ' ' '

+' < "$tmpdepfile" \

+   | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \

+   >> $depfile

+  else

+    # The sourcefile does not contain any dependencies, so just

+    # store a dummy comment line, to avoid errors with the Makefile

+    # "include basename.Plo" scheme.

+    echo "#dummy" > "$depfile"

+  fi

+  rm -f "$tmpdepfile"

+  ;;

+

+aix)

+  # The C for AIX Compiler uses -M and outputs the dependencies

+  # in a .u file.  In older versions, this file always lives in the

+  # current directory.  Also, the AIX compiler puts `$object:' at the

+  # start of each line; $object doesn't have directory information.

+  # Version 6 uses the directory in both cases.

+  stripped=`echo "$object" | sed 's/\(.*\)\..*$/\1/'`

+  tmpdepfile="$stripped.u"

+  if test "$libtool" = yes; then

+    "$@" -Wc,-M

+  else

+    "$@" -M

+  fi

+  stat=$?

+

+  if test -f "$tmpdepfile"; then :

+  else

+    stripped=`echo "$stripped" | sed 's,^.*/,,'`

+    tmpdepfile="$stripped.u"

+  fi

+

+  if test $stat -eq 0; then :

+  else

+    rm -f "$tmpdepfile"

+    exit $stat

+  fi

+

+  if test -f "$tmpdepfile"; then

+    outname="$stripped.o"

+    # Each line is of the form `foo.o: dependent.h'.

+    # Do two passes, one to just change these to

+    # `$object: dependent.h' and one to simply `dependent.h:'.

+    sed -e "s,^$outname:,$object :," < "$tmpdepfile" > "$depfile"

+    sed -e "s,^$outname: \(.*\)$,\1:," < "$tmpdepfile" >> "$depfile"

+  else

+    # The sourcefile does not contain any dependencies, so just

+    # store a dummy comment line, to avoid errors with the Makefile

+    # "include basename.Plo" scheme.

+    echo "#dummy" > "$depfile"

+  fi

+  rm -f "$tmpdepfile"

+  ;;

+

+icc)

+  # Intel's C compiler understands `-MD -MF file'.  However on

+  #    icc -MD -MF foo.d -c -o sub/foo.o sub/foo.c

+  # ICC 7.0 will fill foo.d with something like

+  #    foo.o: sub/foo.c

+  #    foo.o: sub/foo.h

+  # which is wrong.  We want:

+  #    sub/foo.o: sub/foo.c

+  #    sub/foo.o: sub/foo.h

+  #    sub/foo.c:

+  #    sub/foo.h:

+  # ICC 7.1 will output

+  #    foo.o: sub/foo.c sub/foo.h

+  # and will wrap long lines using \ :

+  #    foo.o: sub/foo.c ... \

+  #     sub/foo.h ... \

+  #     ...

+

+  "$@" -MD -MF "$tmpdepfile"

+  stat=$?

+  if test $stat -eq 0; then :

+  else

+    rm -f "$tmpdepfile"

+    exit $stat

+  fi

+  rm -f "$depfile"

+  # Each line is of the form `foo.o: dependent.h',

+  # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.

+  # Do two passes, one to just change these to

+  # `$object: dependent.h' and one to simply `dependent.h:'.

+  sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"

+  # Some versions of the HPUX 10.20 sed can't process this invocation

+  # correctly.  Breaking it into two sed invocations is a workaround.

+  sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" |

+    sed -e 's/$/ :/' >> "$depfile"

+  rm -f "$tmpdepfile"

+  ;;

+

+tru64)

+   # The Tru64 compiler uses -MD to generate dependencies as a side

+   # effect.  `cc -MD -o foo.o ...' puts the dependencies into `foo.o.d'.

+   # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put

+   # dependencies in `foo.d' instead, so we check for that too.

+   # Subdirectories are respected.

+   dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`

+   test "x$dir" = "x$object" && dir=

+   base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`

+

+   if test "$libtool" = yes; then

+      # With Tru64 cc, shared objects can also be used to make a

+      # static library.  This mecanism is used in libtool 1.4 series to

+      # handle both shared and static libraries in a single compilation.

+      # With libtool 1.4, dependencies were output in $dir.libs/$base.lo.d.

+      #

+      # With libtool 1.5 this exception was removed, and libtool now

+      # generates 2 separate objects for the 2 libraries.  These two

+      # compilations output dependencies in in $dir.libs/$base.o.d and

+      # in $dir$base.o.d.  We have to check for both files, because

+      # one of the two compilations can be disabled.  We should prefer

+      # $dir$base.o.d over $dir.libs/$base.o.d because the latter is

+      # automatically cleaned when .libs/ is deleted, while ignoring

+      # the former would cause a distcleancheck panic.

+      tmpdepfile1=$dir.libs/$base.lo.d   # libtool 1.4

+      tmpdepfile2=$dir$base.o.d          # libtool 1.5

+      tmpdepfile3=$dir.libs/$base.o.d    # libtool 1.5

+      tmpdepfile4=$dir.libs/$base.d      # Compaq CCC V6.2-504

+      "$@" -Wc,-MD

+   else

+      tmpdepfile1=$dir$base.o.d

+      tmpdepfile2=$dir$base.d

+      tmpdepfile3=$dir$base.d

+      tmpdepfile4=$dir$base.d

+      "$@" -MD

+   fi

+

+   stat=$?

+   if test $stat -eq 0; then :

+   else

+      rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"

+      exit $stat

+   fi

+

+   for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"

+   do

+     test -f "$tmpdepfile" && break

+   done

+   if test -f "$tmpdepfile"; then

+      sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"

+      # That's a tab and a space in the [].

+      sed -e 's,^.*\.[a-z]*:[	 ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"

+   else

+      echo "#dummy" > "$depfile"

+   fi

+   rm -f "$tmpdepfile"

+   ;;

+

+#nosideeffect)

+  # This comment above is used by automake to tell side-effect

+  # dependency tracking mechanisms from slower ones.

+

+dashmstdout)

+  # Important note: in order to support this mode, a compiler *must*

+  # always write the preprocessed file to stdout, regardless of -o.

+  "$@" || exit $?

+

+  # Remove the call to Libtool.

+  if test "$libtool" = yes; then

+    while test $1 != '--mode=compile'; do

+      shift

+    done

+    shift

+  fi

+

+  # Remove `-o $object'.

+  IFS=" "

+  for arg

+  do

+    case $arg in

+    -o)

+      shift

+      ;;

+    $object)

+      shift

+      ;;

+    *)

+      set fnord "$@" "$arg"

+      shift # fnord

+      shift # $arg

+      ;;

+    esac

+  done

+

+  test -z "$dashmflag" && dashmflag=-M

+  # Require at least two characters before searching for `:'

+  # in the target name.  This is to cope with DOS-style filenames:

+  # a dependency such as `c:/foo/bar' could be seen as target `c' otherwise.

+  "$@" $dashmflag |

+    sed 's:^[  ]*[^: ][^:][^:]*\:[    ]*:'"$object"'\: :' > "$tmpdepfile"

+  rm -f "$depfile"

+  cat < "$tmpdepfile" > "$depfile"

+  tr ' ' '

+' < "$tmpdepfile" | \

+## Some versions of the HPUX 10.20 sed can't process this invocation

+## correctly.  Breaking it into two sed invocations is a workaround.

+    sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"

+  rm -f "$tmpdepfile"

+  ;;

+

+dashXmstdout)

+  # This case only exists to satisfy depend.m4.  It is never actually

+  # run, as this mode is specially recognized in the preamble.

+  exit 1

+  ;;

+

+makedepend)

+  "$@" || exit $?

+  # Remove any Libtool call

+  if test "$libtool" = yes; then

+    while test $1 != '--mode=compile'; do

+      shift

+    done

+    shift

+  fi

+  # X makedepend

+  shift

+  cleared=no

+  for arg in "$@"; do

+    case $cleared in

+    no)

+      set ""; shift

+      cleared=yes ;;

+    esac

+    case "$arg" in

+    -D*|-I*)

+      set fnord "$@" "$arg"; shift ;;

+    # Strip any option that makedepend may not understand.  Remove

+    # the object too, otherwise makedepend will parse it as a source file.

+    -*|$object)

+      ;;

+    *)

+      set fnord "$@" "$arg"; shift ;;

+    esac

+  done

+  obj_suffix="`echo $object | sed 's/^.*\././'`"

+  touch "$tmpdepfile"

+  ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"

+  rm -f "$depfile"

+  cat < "$tmpdepfile" > "$depfile"

+  sed '1,2d' "$tmpdepfile" | tr ' ' '

+' | \

+## Some versions of the HPUX 10.20 sed can't process this invocation

+## correctly.  Breaking it into two sed invocations is a workaround.

+    sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"

+  rm -f "$tmpdepfile" "$tmpdepfile".bak

+  ;;

+

+cpp)

+  # Important note: in order to support this mode, a compiler *must*

+  # always write the preprocessed file to stdout.

+  "$@" || exit $?

+

+  # Remove the call to Libtool.

+  if test "$libtool" = yes; then

+    while test $1 != '--mode=compile'; do

+      shift

+    done

+    shift

+  fi

+

+  # Remove `-o $object'.

+  IFS=" "

+  for arg

+  do

+    case $arg in

+    -o)

+      shift

+      ;;

+    $object)

+      shift

+      ;;

+    *)

+      set fnord "$@" "$arg"

+      shift # fnord

+      shift # $arg

+      ;;

+    esac

+  done

+

+  "$@" -E |

+    sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \

+       -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' |

+    sed '$ s: \\$::' > "$tmpdepfile"

+  rm -f "$depfile"

+  echo "$object : \\" > "$depfile"

+  cat < "$tmpdepfile" >> "$depfile"

+  sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"

+  rm -f "$tmpdepfile"

+  ;;

+

+msvisualcpp)

+  # Important note: in order to support this mode, a compiler *must*

+  # always write the preprocessed file to stdout, regardless of -o,

+  # because we must use -o when running libtool.

+  "$@" || exit $?

+  IFS=" "

+  for arg

+  do

+    case "$arg" in

+    "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")

+	set fnord "$@"

+	shift

+	shift

+	;;

+    *)

+	set fnord "$@" "$arg"

+	shift

+	shift

+	;;

+    esac

+  done

+  "$@" -E |

+  sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::echo "`cygpath -u \\"\1\\"`":p' | sort | uniq > "$tmpdepfile"

+  rm -f "$depfile"

+  echo "$object : \\" > "$depfile"

+  . "$tmpdepfile" | sed 's% %\\ %g' | sed -n '/^\(.*\)$/ s::	\1 \\:p' >> "$depfile"

+  echo "	" >> "$depfile"

+  . "$tmpdepfile" | sed 's% %\\ %g' | sed -n '/^\(.*\)$/ s::\1\::p' >> "$depfile"

+  rm -f "$tmpdepfile"

+  ;;

+

+none)

+  exec "$@"

+  ;;

+

+*)

+  echo "Unknown depmode $depmode" 1>&2

+  exit 1

+  ;;

+esac

+

+exit 0

+

+# Local Variables:

+# mode: shell-script

+# sh-indentation: 2

+# eval: (add-hook 'write-file-hooks 'time-stamp)

+# time-stamp-start: "scriptversion="

+# time-stamp-format: "%:y-%02m-%02d.%02H"

+# time-stamp-end: "$"

+# End:

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/install-sh b/sdch/open_vcdiff/depot/opensource/open-vcdiff/install-sh
new file mode 100644
index 0000000..127f5ef
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/install-sh
@@ -0,0 +1,323 @@
+#!/bin/sh

+# install - install a program, script, or datafile

+

+scriptversion=2005-05-14.22

+

+# This originates from X11R5 (mit/util/scripts/install.sh), which was

+# later released in X11R6 (xc/config/util/install.sh) with the

+# following copyright and license.

+#

+# Copyright (C) 1994 X Consortium

+#

+# Permission is hereby granted, free of charge, to any person obtaining a copy

+# of this software and associated documentation files (the "Software"), to

+# deal in the Software without restriction, including without limitation the

+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

+# sell copies of the Software, and to permit persons to whom the Software is

+# furnished to do so, subject to the following conditions:

+#

+# The above copyright notice and this permission notice shall be included in

+# all copies or substantial portions of the Software.

+#

+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

+# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-

+# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+#

+# Except as contained in this notice, the name of the X Consortium shall not

+# be used in advertising or otherwise to promote the sale, use or other deal-

+# ings in this Software without prior written authorization from the X Consor-

+# tium.

+#

+#

+# FSF changes to this file are in the public domain.

+#

+# Calling this script install-sh is preferred over install.sh, to prevent

+# `make' implicit rules from creating a file called install from it

+# when there is no Makefile.

+#

+# This script is compatible with the BSD install script, but was written

+# from scratch.  It can only install one file at a time, a restriction

+# shared with many OS's install programs.

+

+# set DOITPROG to echo to test this script

+

+# Don't use :- since 4.3BSD and earlier shells don't like it.

+doit="${DOITPROG-}"

+

+# put in absolute paths if you don't have them in your path; or use env. vars.

+

+mvprog="${MVPROG-mv}"

+cpprog="${CPPROG-cp}"

+chmodprog="${CHMODPROG-chmod}"

+chownprog="${CHOWNPROG-chown}"

+chgrpprog="${CHGRPPROG-chgrp}"

+stripprog="${STRIPPROG-strip}"

+rmprog="${RMPROG-rm}"

+mkdirprog="${MKDIRPROG-mkdir}"

+

+chmodcmd="$chmodprog 0755"

+chowncmd=

+chgrpcmd=

+stripcmd=

+rmcmd="$rmprog -f"

+mvcmd="$mvprog"

+src=

+dst=

+dir_arg=

+dstarg=

+no_target_directory=

+

+usage="Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE

+   or: $0 [OPTION]... SRCFILES... DIRECTORY

+   or: $0 [OPTION]... -t DIRECTORY SRCFILES...

+   or: $0 [OPTION]... -d DIRECTORIES...

+

+In the 1st form, copy SRCFILE to DSTFILE.

+In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.

+In the 4th, create DIRECTORIES.

+

+Options:

+-c         (ignored)

+-d         create directories instead of installing files.

+-g GROUP   $chgrpprog installed files to GROUP.

+-m MODE    $chmodprog installed files to MODE.

+-o USER    $chownprog installed files to USER.

+-s         $stripprog installed files.

+-t DIRECTORY  install into DIRECTORY.

+-T         report an error if DSTFILE is a directory.

+--help     display this help and exit.

+--version  display version info and exit.

+

+Environment variables override the default commands:

+  CHGRPPROG CHMODPROG CHOWNPROG CPPROG MKDIRPROG MVPROG RMPROG STRIPPROG

+"

+

+while test -n "$1"; do

+  case $1 in

+    -c) shift

+        continue;;

+

+    -d) dir_arg=true

+        shift

+        continue;;

+

+    -g) chgrpcmd="$chgrpprog $2"

+        shift

+        shift

+        continue;;

+

+    --help) echo "$usage"; exit $?;;

+

+    -m) chmodcmd="$chmodprog $2"

+        shift

+        shift

+        continue;;

+

+    -o) chowncmd="$chownprog $2"

+        shift

+        shift

+        continue;;

+

+    -s) stripcmd=$stripprog

+        shift

+        continue;;

+

+    -t) dstarg=$2

+	shift

+	shift

+	continue;;

+

+    -T) no_target_directory=true

+	shift

+	continue;;

+

+    --version) echo "$0 $scriptversion"; exit $?;;

+

+    *)  # When -d is used, all remaining arguments are directories to create.

+	# When -t is used, the destination is already specified.

+	test -n "$dir_arg$dstarg" && break

+        # Otherwise, the last argument is the destination.  Remove it from $@.

+	for arg

+	do

+          if test -n "$dstarg"; then

+	    # $@ is not empty: it contains at least $arg.

+	    set fnord "$@" "$dstarg"

+	    shift # fnord

+	  fi

+	  shift # arg

+	  dstarg=$arg

+	done

+	break;;

+  esac

+done

+

+if test -z "$1"; then

+  if test -z "$dir_arg"; then

+    echo "$0: no input file specified." >&2

+    exit 1

+  fi

+  # It's OK to call `install-sh -d' without argument.

+  # This can happen when creating conditional directories.

+  exit 0

+fi

+

+for src

+do

+  # Protect names starting with `-'.

+  case $src in

+    -*) src=./$src ;;

+  esac

+

+  if test -n "$dir_arg"; then

+    dst=$src

+    src=

+

+    if test -d "$dst"; then

+      mkdircmd=:

+      chmodcmd=

+    else

+      mkdircmd=$mkdirprog

+    fi

+  else

+    # Waiting for this to be detected by the "$cpprog $src $dsttmp" command

+    # might cause directories to be created, which would be especially bad

+    # if $src (and thus $dsttmp) contains '*'.

+    if test ! -f "$src" && test ! -d "$src"; then

+      echo "$0: $src does not exist." >&2

+      exit 1

+    fi

+

+    if test -z "$dstarg"; then

+      echo "$0: no destination specified." >&2

+      exit 1

+    fi

+

+    dst=$dstarg

+    # Protect names starting with `-'.

+    case $dst in

+      -*) dst=./$dst ;;

+    esac

+

+    # If destination is a directory, append the input filename; won't work

+    # if double slashes aren't ignored.

+    if test -d "$dst"; then

+      if test -n "$no_target_directory"; then

+	echo "$0: $dstarg: Is a directory" >&2

+	exit 1

+      fi

+      dst=$dst/`basename "$src"`

+    fi

+  fi

+

+  # This sed command emulates the dirname command.

+  dstdir=`echo "$dst" | sed -e 's,/*$,,;s,[^/]*$,,;s,/*$,,;s,^$,.,'`

+

+  # Make sure that the destination directory exists.

+

+  # Skip lots of stat calls in the usual case.

+  if test ! -d "$dstdir"; then

+    defaultIFS='

+	 '

+    IFS="${IFS-$defaultIFS}"

+

+    oIFS=$IFS

+    # Some sh's can't handle IFS=/ for some reason.

+    IFS='%'

+    set x `echo "$dstdir" | sed -e 's@/@%@g' -e 's@^%@/@'`

+    shift

+    IFS=$oIFS

+

+    pathcomp=

+

+    while test $# -ne 0 ; do

+      pathcomp=$pathcomp$1

+      shift

+      if test ! -d "$pathcomp"; then

+        $mkdirprog "$pathcomp"

+	# mkdir can fail with a `File exist' error in case several

+	# install-sh are creating the directory concurrently.  This

+	# is OK.

+	test -d "$pathcomp" || exit

+      fi

+      pathcomp=$pathcomp/

+    done

+  fi

+

+  if test -n "$dir_arg"; then

+    $doit $mkdircmd "$dst" \

+      && { test -z "$chowncmd" || $doit $chowncmd "$dst"; } \

+      && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } \

+      && { test -z "$stripcmd" || $doit $stripcmd "$dst"; } \

+      && { test -z "$chmodcmd" || $doit $chmodcmd "$dst"; }

+

+  else

+    dstfile=`basename "$dst"`

+

+    # Make a couple of temp file names in the proper directory.

+    dsttmp=$dstdir/_inst.$$_

+    rmtmp=$dstdir/_rm.$$_

+

+    # Trap to clean up those temp files at exit.

+    trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0

+    trap '(exit $?); exit' 1 2 13 15

+

+    # Copy the file name to the temp name.

+    $doit $cpprog "$src" "$dsttmp" &&

+

+    # and set any options; do chmod last to preserve setuid bits.

+    #

+    # If any of these fail, we abort the whole thing.  If we want to

+    # ignore errors from any of these, just make sure not to ignore

+    # errors from the above "$doit $cpprog $src $dsttmp" command.

+    #

+    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } \

+      && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } \

+      && { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } \

+      && { test -z "$chmodcmd" || $doit $chmodcmd "$dsttmp"; } &&

+

+    # Now rename the file to the real destination.

+    { $doit $mvcmd -f "$dsttmp" "$dstdir/$dstfile" 2>/dev/null \

+      || {

+	   # The rename failed, perhaps because mv can't rename something else

+	   # to itself, or perhaps because mv is so ancient that it does not

+	   # support -f.

+

+	   # Now remove or move aside any old file at destination location.

+	   # We try this two ways since rm can't unlink itself on some

+	   # systems and the destination file might be busy for other

+	   # reasons.  In this case, the final cleanup might fail but the new

+	   # file should still install successfully.

+	   {

+	     if test -f "$dstdir/$dstfile"; then

+	       $doit $rmcmd -f "$dstdir/$dstfile" 2>/dev/null \

+	       || $doit $mvcmd -f "$dstdir/$dstfile" "$rmtmp" 2>/dev/null \

+	       || {

+		 echo "$0: cannot unlink or rename $dstdir/$dstfile" >&2

+		 (exit 1); exit 1

+	       }

+	     else

+	       :

+	     fi

+	   } &&

+

+	   # Now rename the file to the real destination.

+	   $doit $mvcmd "$dsttmp" "$dstdir/$dstfile"

+	 }

+    }

+  fi || { (exit 1); exit 1; }

+done

+

+# The final little trick to "correctly" pass the exit status to the exit trap.

+{

+  (exit 0); exit 0

+}

+

+# Local variables:

+# eval: (add-hook 'write-file-hooks 'time-stamp)

+# time-stamp-start: "scriptversion="

+# time-stamp-format: "%:y-%02m-%02d.%02H"

+# time-stamp-end: "$"

+# End:

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/ltmain.sh b/sdch/open_vcdiff/depot/opensource/open-vcdiff/ltmain.sh
new file mode 100755
index 0000000..8fc56db
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/ltmain.sh
@@ -0,0 +1,6871 @@
+# ltmain.sh - Provide generalized library-building support services.
+# NOTE: Changing this file will not affect anything until you rerun configure.
+#
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005
+# Free Software Foundation, Inc.
+# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+basename="s,^.*/,,g"
+
+# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
+# is ksh but when the shell is invoked as "sh" and the current value of
+# the _XPG environment variable is not equal to 1 (one), the special
+# positional parameter $0, within a function call, is the name of the
+# function.
+progpath="$0"
+
+# The name of this program:
+progname=`echo "$progpath" | $SED $basename`
+modename="$progname"
+
+# Global variables:
+EXIT_SUCCESS=0
+EXIT_FAILURE=1
+
+PROGRAM=ltmain.sh
+PACKAGE=libtool
+VERSION="1.5.22 Debian 1.5.22-2"
+TIMESTAMP=" (1.1220.2.365 2005/12/18 22:14:06)"
+
+# See if we are running on zsh, and set the options which allow our
+# commands through without removal of \ escapes.
+if test -n "${ZSH_VERSION+set}" ; then
+  setopt NO_GLOB_SUBST
+fi
+
+# Check that we have a working $echo.
+if test "X$1" = X--no-reexec; then
+  # Discard the --no-reexec flag, and continue.
+  shift
+elif test "X$1" = X--fallback-echo; then
+  # Avoid inline document here, it may be left over
+  :
+elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
+  # Yippee, $echo works!
+  :
+else
+  # Restart under the correct shell, and then maybe $echo will work.
+  exec $SHELL "$progpath" --no-reexec ${1+"$@"}
+fi
+
+if test "X$1" = X--fallback-echo; then
+  # used as fallback echo
+  shift
+  cat <<EOF
+$*
+EOF
+  exit $EXIT_SUCCESS
+fi
+
+default_mode=
+help="Try \`$progname --help' for more information."
+magic="%%%MAGIC variable%%%"
+mkdir="mkdir"
+mv="mv -f"
+rm="rm -f"
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+Xsed="${SED}"' -e 1s/^X//'
+sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
+# test EBCDIC or ASCII
+case `echo X|tr X '\101'` in
+ A) # ASCII based system
+    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
+  SP2NL='tr \040 \012'
+  NL2SP='tr \015\012 \040\040'
+  ;;
+ *) # EBCDIC based system
+  SP2NL='tr \100 \n'
+  NL2SP='tr \r\n \100\100'
+  ;;
+esac
+
+# NLS nuisances.
+# Only set LANG and LC_ALL to C if already set.
+# These must not be set unconditionally because not all systems understand
+# e.g. LANG=C (notably SCO).
+# We save the old values to restore during execute mode.
+if test "${LC_ALL+set}" = set; then
+  save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
+fi
+if test "${LANG+set}" = set; then
+  save_LANG="$LANG"; LANG=C; export LANG
+fi
+
+# Make sure IFS has a sensible default
+lt_nl='
+'
+IFS=" 	$lt_nl"
+
+if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
+  $echo "$modename: not configured to build any kind of library" 1>&2
+  $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
+  exit $EXIT_FAILURE
+fi
+
+# Global variables.
+mode=$default_mode
+nonopt=
+prev=
+prevopt=
+run=
+show="$echo"
+show_help=
+execute_dlfiles=
+duplicate_deps=no
+preserve_args=
+lo2o="s/\\.lo\$/.${objext}/"
+o2lo="s/\\.${objext}\$/.lo/"
+
+#####################################
+# Shell function definitions:
+# This seems to be the best place for them
+
+# func_mktempdir [string]
+# Make a temporary directory that won't clash with other running
+# libtool processes, and avoids race conditions if possible.  If
+# given, STRING is the basename for that directory.
+func_mktempdir ()
+{
+    my_template="${TMPDIR-/tmp}/${1-$progname}"
+
+    if test "$run" = ":"; then
+      # Return a directory name, but don't create it in dry-run mode
+      my_tmpdir="${my_template}-$$"
+    else
+
+      # If mktemp works, use that first and foremost
+      my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
+
+      if test ! -d "$my_tmpdir"; then
+	# Failing that, at least try and use $RANDOM to avoid a race
+	my_tmpdir="${my_template}-${RANDOM-0}$$"
+
+	save_mktempdir_umask=`umask`
+	umask 0077
+	$mkdir "$my_tmpdir"
+	umask $save_mktempdir_umask
+      fi
+
+      # If we're not in dry-run mode, bomb out on failure
+      test -d "$my_tmpdir" || {
+        $echo "cannot create temporary directory \`$my_tmpdir'" 1>&2
+	exit $EXIT_FAILURE
+      }
+    fi
+
+    $echo "X$my_tmpdir" | $Xsed
+}
+
+
+# func_win32_libid arg
+# return the library type of file 'arg'
+#
+# Need a lot of goo to handle *both* DLLs and import libs
+# Has to be a shell function in order to 'eat' the argument
+# that is supplied when $file_magic_command is called.
+func_win32_libid ()
+{
+  win32_libid_type="unknown"
+  win32_fileres=`file -L $1 2>/dev/null`
+  case $win32_fileres in
+  *ar\ archive\ import\ library*) # definitely import
+    win32_libid_type="x86 archive import"
+    ;;
+  *ar\ archive*) # could be an import, or static
+    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
+      $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
+      win32_nmres=`eval $NM -f posix -A $1 | \
+	$SED -n -e '1,100{/ I /{s,.*,import,;p;q;};}'`
+      case $win32_nmres in
+      import*)  win32_libid_type="x86 archive import";;
+      *)        win32_libid_type="x86 archive static";;
+      esac
+    fi
+    ;;
+  *DLL*)
+    win32_libid_type="x86 DLL"
+    ;;
+  *executable*) # but shell scripts are "executable" too...
+    case $win32_fileres in
+    *MS\ Windows\ PE\ Intel*)
+      win32_libid_type="x86 DLL"
+      ;;
+    esac
+    ;;
+  esac
+  $echo $win32_libid_type
+}
+
+
+# func_infer_tag arg
+# Infer tagged configuration to use if any are available and
+# if one wasn't chosen via the "--tag" command line option.
+# Only attempt this if the compiler in the base compile
+# command doesn't match the default compiler.
+# arg is usually of the form 'gcc ...'
+func_infer_tag ()
+{
+    if test -n "$available_tags" && test -z "$tagname"; then
+      CC_quoted=
+      for arg in $CC; do
+	case $arg in
+	  *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	  arg="\"$arg\""
+	  ;;
+	esac
+	CC_quoted="$CC_quoted $arg"
+      done
+      case $@ in
+      # Blanks in the command may have been stripped by the calling shell,
+      # but not from the CC environment variable when configure was run.
+      " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) ;;
+      # Blanks at the start of $base_compile will cause this to fail
+      # if we don't check for them as well.
+      *)
+	for z in $available_tags; do
+	  if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
+	    # Evaluate the configuration.
+	    eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
+	    CC_quoted=
+	    for arg in $CC; do
+	    # Double-quote args containing other shell metacharacters.
+	    case $arg in
+	      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	      arg="\"$arg\""
+	      ;;
+	    esac
+	    CC_quoted="$CC_quoted $arg"
+	  done
+	    case "$@ " in
+	      " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*)
+	      # The compiler in the base compile command matches
+	      # the one in the tagged configuration.
+	      # Assume this is the tagged configuration we want.
+	      tagname=$z
+	      break
+	      ;;
+	    esac
+	  fi
+	done
+	# If $tagname still isn't set, then no tagged configuration
+	# was found and let the user know that the "--tag" command
+	# line option must be used.
+	if test -z "$tagname"; then
+	  $echo "$modename: unable to infer tagged configuration"
+	  $echo "$modename: specify a tag with \`--tag'" 1>&2
+	  exit $EXIT_FAILURE
+#        else
+#          $echo "$modename: using $tagname tagged configuration"
+	fi
+	;;
+      esac
+    fi
+}
+
+
+# func_extract_an_archive dir oldlib
+func_extract_an_archive ()
+{
+    f_ex_an_ar_dir="$1"; shift
+    f_ex_an_ar_oldlib="$1"
+
+    $show "(cd $f_ex_an_ar_dir && $AR x $f_ex_an_ar_oldlib)"
+    $run eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" || exit $?
+    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
+     :
+    else
+      $echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2
+      exit $EXIT_FAILURE
+    fi
+}
+
+# func_extract_archives gentop oldlib ...
+func_extract_archives ()
+{
+    my_gentop="$1"; shift
+    my_oldlibs=${1+"$@"}
+    my_oldobjs=""
+    my_xlib=""
+    my_xabs=""
+    my_xdir=""
+    my_status=""
+
+    $show "${rm}r $my_gentop"
+    $run ${rm}r "$my_gentop"
+    $show "$mkdir $my_gentop"
+    $run $mkdir "$my_gentop"
+    my_status=$?
+    if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then
+      exit $my_status
+    fi
+
+    for my_xlib in $my_oldlibs; do
+      # Extract the objects.
+      case $my_xlib in
+	[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
+	*) my_xabs=`pwd`"/$my_xlib" ;;
+      esac
+      my_xlib=`$echo "X$my_xlib" | $Xsed -e 's%^.*/%%'`
+      my_xdir="$my_gentop/$my_xlib"
+
+      $show "${rm}r $my_xdir"
+      $run ${rm}r "$my_xdir"
+      $show "$mkdir $my_xdir"
+      $run $mkdir "$my_xdir"
+      exit_status=$?
+      if test "$exit_status" -ne 0 && test ! -d "$my_xdir"; then
+	exit $exit_status
+      fi
+      case $host in
+      *-darwin*)
+	$show "Extracting $my_xabs"
+	# Do not bother doing anything if just a dry run
+	if test -z "$run"; then
+	  darwin_orig_dir=`pwd`
+	  cd $my_xdir || exit $?
+	  darwin_archive=$my_xabs
+	  darwin_curdir=`pwd`
+	  darwin_base_archive=`$echo "X$darwin_archive" | $Xsed -e 's%^.*/%%'`
+	  darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $EGREP Architectures 2>/dev/null`
+	  if test -n "$darwin_arches"; then 
+	    darwin_arches=`echo "$darwin_arches" | $SED -e 's/.*are://'`
+	    darwin_arch=
+	    $show "$darwin_base_archive has multiple architectures $darwin_arches"
+	    for darwin_arch in  $darwin_arches ; do
+	      mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
+	      lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
+	      cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
+	      func_extract_an_archive "`pwd`" "${darwin_base_archive}"
+	      cd "$darwin_curdir"
+	      $rm "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
+	    done # $darwin_arches
+      ## Okay now we have a bunch of thin objects, gotta fatten them up :)
+	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print| xargs basename | sort -u | $NL2SP`
+	    darwin_file=
+	    darwin_files=
+	    for darwin_file in $darwin_filelist; do
+	      darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
+	      lipo -create -output "$darwin_file" $darwin_files
+	    done # $darwin_filelist
+	    ${rm}r unfat-$$
+	    cd "$darwin_orig_dir"
+	  else
+	    cd "$darwin_orig_dir"
+ 	    func_extract_an_archive "$my_xdir" "$my_xabs"
+	  fi # $darwin_arches
+	fi # $run
+	;;
+      *)
+        func_extract_an_archive "$my_xdir" "$my_xabs"
+        ;;
+      esac
+      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
+    done
+    func_extract_archives_result="$my_oldobjs"
+}
+# End of Shell function definitions
+#####################################
+
+# Darwin sucks
+eval std_shrext=\"$shrext_cmds\"
+
+disable_libs=no
+
+# Parse our command line options once, thoroughly.
+while test "$#" -gt 0
+do
+  arg="$1"
+  shift
+
+  case $arg in
+  -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
+  *) optarg= ;;
+  esac
+
+  # If the previous option needs an argument, assign it.
+  if test -n "$prev"; then
+    case $prev in
+    execute_dlfiles)
+      execute_dlfiles="$execute_dlfiles $arg"
+      ;;
+    tag)
+      tagname="$arg"
+      preserve_args="${preserve_args}=$arg"
+
+      # Check whether tagname contains only valid characters
+      case $tagname in
+      *[!-_A-Za-z0-9,/]*)
+	$echo "$progname: invalid tag name: $tagname" 1>&2
+	exit $EXIT_FAILURE
+	;;
+      esac
+
+      case $tagname in
+      CC)
+	# Don't test for the "default" C tag, as we know, it's there, but
+	# not specially marked.
+	;;
+      *)
+	if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then
+	  taglist="$taglist $tagname"
+	  # Evaluate the configuration.
+	  eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`"
+	else
+	  $echo "$progname: ignoring unknown tag $tagname" 1>&2
+	fi
+	;;
+      esac
+      ;;
+    *)
+      eval "$prev=\$arg"
+      ;;
+    esac
+
+    prev=
+    prevopt=
+    continue
+  fi
+
+  # Have we seen a non-optional argument yet?
+  case $arg in
+  --help)
+    show_help=yes
+    ;;
+
+  --version)
+    $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
+    $echo
+    $echo "Copyright (C) 2005  Free Software Foundation, Inc."
+    $echo "This is free software; see the source for copying conditions.  There is NO"
+    $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+    exit $?
+    ;;
+
+  --config)
+    ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
+    # Now print the configurations for the tags.
+    for tagname in $taglist; do
+      ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
+    done
+    exit $?
+    ;;
+
+  --debug)
+    $echo "$progname: enabling shell trace mode"
+    set -x
+    preserve_args="$preserve_args $arg"
+    ;;
+
+  --dry-run | -n)
+    run=:
+    ;;
+
+  --features)
+    $echo "host: $host"
+    if test "$build_libtool_libs" = yes; then
+      $echo "enable shared libraries"
+    else
+      $echo "disable shared libraries"
+    fi
+    if test "$build_old_libs" = yes; then
+      $echo "enable static libraries"
+    else
+      $echo "disable static libraries"
+    fi
+    exit $?
+    ;;
+
+  --finish) mode="finish" ;;
+
+  --mode) prevopt="--mode" prev=mode ;;
+  --mode=*) mode="$optarg" ;;
+
+  --preserve-dup-deps) duplicate_deps="yes" ;;
+
+  --quiet | --silent)
+    show=:
+    preserve_args="$preserve_args $arg"
+    ;;
+
+  --tag)
+    prevopt="--tag"
+    prev=tag
+    preserve_args="$preserve_args --tag"
+    ;;
+  --tag=*)
+    set tag "$optarg" ${1+"$@"}
+    shift
+    prev=tag
+    preserve_args="$preserve_args --tag"
+    ;;
+
+  -dlopen)
+    prevopt="-dlopen"
+    prev=execute_dlfiles
+    ;;
+
+  -*)
+    $echo "$modename: unrecognized option \`$arg'" 1>&2
+    $echo "$help" 1>&2
+    exit $EXIT_FAILURE
+    ;;
+
+  *)
+    nonopt="$arg"
+    break
+    ;;
+  esac
+done
+
+if test -n "$prevopt"; then
+  $echo "$modename: option \`$prevopt' requires an argument" 1>&2
+  $echo "$help" 1>&2
+  exit $EXIT_FAILURE
+fi
+
+case $disable_libs in
+no) 
+  ;;
+shared)
+  build_libtool_libs=no
+  build_old_libs=yes
+  ;;
+static)
+  build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
+  ;;
+esac
+
+# If this variable is set in any of the actions, the command in it
+# will be execed at the end.  This prevents here-documents from being
+# left over by shells.
+exec_cmd=
+
+if test -z "$show_help"; then
+
+  # Infer the operation mode.
+  if test -z "$mode"; then
+    $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
+    $echo "*** Future versions of Libtool will require --mode=MODE be specified." 1>&2
+    case $nonopt in
+    *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
+      mode=link
+      for arg
+      do
+	case $arg in
+	-c)
+	   mode=compile
+	   break
+	   ;;
+	esac
+      done
+      ;;
+    *db | *dbx | *strace | *truss)
+      mode=execute
+      ;;
+    *install*|cp|mv)
+      mode=install
+      ;;
+    *rm)
+      mode=uninstall
+      ;;
+    *)
+      # If we have no mode, but dlfiles were specified, then do execute mode.
+      test -n "$execute_dlfiles" && mode=execute
+
+      # Just use the default operation mode.
+      if test -z "$mode"; then
+	if test -n "$nonopt"; then
+	  $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
+	else
+	  $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
+	fi
+      fi
+      ;;
+    esac
+  fi
+
+  # Only execute mode is allowed to have -dlopen flags.
+  if test -n "$execute_dlfiles" && test "$mode" != execute; then
+    $echo "$modename: unrecognized option \`-dlopen'" 1>&2
+    $echo "$help" 1>&2
+    exit $EXIT_FAILURE
+  fi
+
+  # Change the help message to a mode-specific one.
+  generic_help="$help"
+  help="Try \`$modename --help --mode=$mode' for more information."
+
+  # These modes are in order of execution frequency so that they run quickly.
+  case $mode in
+  # libtool compile mode
+  compile)
+    modename="$modename: compile"
+    # Get the compilation command and the source file.
+    base_compile=
+    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
+    suppress_opt=yes
+    suppress_output=
+    arg_mode=normal
+    libobj=
+    later=
+
+    for arg
+    do
+      case $arg_mode in
+      arg  )
+	# do not "continue".  Instead, add this to base_compile
+	lastarg="$arg"
+	arg_mode=normal
+	;;
+
+      target )
+	libobj="$arg"
+	arg_mode=normal
+	continue
+	;;
+
+      normal )
+	# Accept any command-line options.
+	case $arg in
+	-o)
+	  if test -n "$libobj" ; then
+	    $echo "$modename: you cannot specify \`-o' more than once" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+	  arg_mode=target
+	  continue
+	  ;;
+
+	-static | -prefer-pic | -prefer-non-pic)
+	  later="$later $arg"
+	  continue
+	  ;;
+
+	-no-suppress)
+	  suppress_opt=no
+	  continue
+	  ;;
+
+	-Xcompiler)
+	  arg_mode=arg  #  the next one goes into the "base_compile" arg list
+	  continue      #  The current "srcfile" will either be retained or
+	  ;;            #  replaced later.  I would guess that would be a bug.
+
+	-Wc,*)
+	  args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
+	  lastarg=
+	  save_ifs="$IFS"; IFS=','
+ 	  for arg in $args; do
+	    IFS="$save_ifs"
+
+	    # Double-quote args containing other shell metacharacters.
+	    # Many Bourne shells cannot handle close brackets correctly
+	    # in scan sets, so we specify it separately.
+	    case $arg in
+	      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	      arg="\"$arg\""
+	      ;;
+	    esac
+	    lastarg="$lastarg $arg"
+	  done
+	  IFS="$save_ifs"
+	  lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
+
+	  # Add the arguments to base_compile.
+	  base_compile="$base_compile $lastarg"
+	  continue
+	  ;;
+
+	* )
+	  # Accept the current argument as the source file.
+	  # The previous "srcfile" becomes the current argument.
+	  #
+	  lastarg="$srcfile"
+	  srcfile="$arg"
+	  ;;
+	esac  #  case $arg
+	;;
+      esac    #  case $arg_mode
+
+      # Aesthetically quote the previous argument.
+      lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
+
+      case $lastarg in
+      # Double-quote args containing other shell metacharacters.
+      # Many Bourne shells cannot handle close brackets correctly
+      # in scan sets, and some SunOS ksh mistreat backslash-escaping
+      # in scan sets (worked around with variable expansion),
+      # and furthermore cannot handle '|' '&' '(' ')' in scan sets 
+      # at all, so we specify them separately.
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	lastarg="\"$lastarg\""
+	;;
+      esac
+
+      base_compile="$base_compile $lastarg"
+    done # for arg
+
+    case $arg_mode in
+    arg)
+      $echo "$modename: you must specify an argument for -Xcompile"
+      exit $EXIT_FAILURE
+      ;;
+    target)
+      $echo "$modename: you must specify a target with \`-o'" 1>&2
+      exit $EXIT_FAILURE
+      ;;
+    *)
+      # Get the name of the library object.
+      [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
+      ;;
+    esac
+
+    # Recognize several different file suffixes.
+    # If the user specifies -o file.o, it is replaced with file.lo
+    xform='[cCFSifmso]'
+    case $libobj in
+    *.ada) xform=ada ;;
+    *.adb) xform=adb ;;
+    *.ads) xform=ads ;;
+    *.asm) xform=asm ;;
+    *.c++) xform=c++ ;;
+    *.cc) xform=cc ;;
+    *.ii) xform=ii ;;
+    *.class) xform=class ;;
+    *.cpp) xform=cpp ;;
+    *.cxx) xform=cxx ;;
+    *.f90) xform=f90 ;;
+    *.for) xform=for ;;
+    *.java) xform=java ;;
+    esac
+
+    libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
+
+    case $libobj in
+    *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
+    *)
+      $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
+      exit $EXIT_FAILURE
+      ;;
+    esac
+
+    func_infer_tag $base_compile
+
+    for arg in $later; do
+      case $arg in
+      -static)
+	build_old_libs=yes
+	continue
+	;;
+
+      -prefer-pic)
+	pic_mode=yes
+	continue
+	;;
+
+      -prefer-non-pic)
+	pic_mode=no
+	continue
+	;;
+      esac
+    done
+
+    qlibobj=`$echo "X$libobj" | $Xsed -e "$sed_quote_subst"`
+    case $qlibobj in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	qlibobj="\"$qlibobj\"" ;;
+    esac
+    test "X$libobj" != "X$qlibobj" \
+	&& $echo "X$libobj" | grep '[]~#^*{};<>?"'"'"' 	&()|`$[]' \
+	&& $echo "$modename: libobj name \`$libobj' may not contain shell special characters."
+    objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
+    xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
+    if test "X$xdir" = "X$obj"; then
+      xdir=
+    else
+      xdir=$xdir/
+    fi
+    lobj=${xdir}$objdir/$objname
+
+    if test -z "$base_compile"; then
+      $echo "$modename: you must specify a compilation command" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    # Delete any leftover library objects.
+    if test "$build_old_libs" = yes; then
+      removelist="$obj $lobj $libobj ${libobj}T"
+    else
+      removelist="$lobj $libobj ${libobj}T"
+    fi
+
+    $run $rm $removelist
+    trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
+
+    # On Cygwin there's no "real" PIC flag so we must build both object types
+    case $host_os in
+    cygwin* | mingw* | pw32* | os2*)
+      pic_mode=default
+      ;;
+    esac
+    if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
+      # non-PIC code in shared libraries is not supported
+      pic_mode=default
+    fi
+
+    # Calculate the filename of the output object if compiler does
+    # not support -o with -c
+    if test "$compiler_c_o" = no; then
+      output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
+      lockfile="$output_obj.lock"
+      removelist="$removelist $output_obj $lockfile"
+      trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
+    else
+      output_obj=
+      need_locks=no
+      lockfile=
+    fi
+
+    # Lock this critical section if it is needed
+    # We use this script file to make the link, it avoids creating a new file
+    if test "$need_locks" = yes; then
+      until $run ln "$progpath" "$lockfile" 2>/dev/null; do
+	$show "Waiting for $lockfile to be removed"
+	sleep 2
+      done
+    elif test "$need_locks" = warn; then
+      if test -f "$lockfile"; then
+	$echo "\
+*** ERROR, $lockfile exists and contains:
+`cat $lockfile 2>/dev/null`
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support \`-c' and \`-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$run $rm $removelist
+	exit $EXIT_FAILURE
+      fi
+      $echo "$srcfile" > "$lockfile"
+    fi
+
+    if test -n "$fix_srcfile_path"; then
+      eval srcfile=\"$fix_srcfile_path\"
+    fi
+    qsrcfile=`$echo "X$srcfile" | $Xsed -e "$sed_quote_subst"`
+    case $qsrcfile in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+      qsrcfile="\"$qsrcfile\"" ;;
+    esac
+
+    $run $rm "$libobj" "${libobj}T"
+
+    # Create a libtool object file (analogous to a ".la" file),
+    # but don't create it if we're doing a dry run.
+    test -z "$run" && cat > ${libobj}T <<EOF
+# $libobj - a libtool object file
+# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# Name of the PIC object.
+EOF
+
+    # Only build a PIC object if we are building libtool libraries.
+    if test "$build_libtool_libs" = yes; then
+      # Without this assignment, base_compile gets emptied.
+      fbsd_hideous_sh_bug=$base_compile
+
+      if test "$pic_mode" != no; then
+	command="$base_compile $qsrcfile $pic_flag"
+      else
+	# Don't build PIC code
+	command="$base_compile $qsrcfile"
+      fi
+
+      if test ! -d "${xdir}$objdir"; then
+	$show "$mkdir ${xdir}$objdir"
+	$run $mkdir ${xdir}$objdir
+	exit_status=$?
+	if test "$exit_status" -ne 0 && test ! -d "${xdir}$objdir"; then
+	  exit $exit_status
+	fi
+      fi
+
+      if test -z "$output_obj"; then
+	# Place PIC objects in $objdir
+	command="$command -o $lobj"
+      fi
+
+      $run $rm "$lobj" "$output_obj"
+
+      $show "$command"
+      if $run eval "$command"; then :
+      else
+	test -n "$output_obj" && $run $rm $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      if test "$need_locks" = warn &&
+	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
+	$echo "\
+*** ERROR, $lockfile contains:
+`cat $lockfile 2>/dev/null`
+
+but it should contain:
+$srcfile
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support \`-c' and \`-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$run $rm $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      # Just move the object if needed, then go on to compile the next one
+      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
+	$show "$mv $output_obj $lobj"
+	if $run $mv $output_obj $lobj; then :
+	else
+	  error=$?
+	  $run $rm $removelist
+	  exit $error
+	fi
+      fi
+
+      # Append the name of the PIC object to the libtool object file.
+      test -z "$run" && cat >> ${libobj}T <<EOF
+pic_object='$objdir/$objname'
+
+EOF
+
+      # Allow error messages only from the first compilation.
+      if test "$suppress_opt" = yes; then
+        suppress_output=' >/dev/null 2>&1'
+      fi
+    else
+      # No PIC object so indicate it doesn't exist in the libtool
+      # object file.
+      test -z "$run" && cat >> ${libobj}T <<EOF
+pic_object=none
+
+EOF
+    fi
+
+    # Only build a position-dependent object if we build old libraries.
+    if test "$build_old_libs" = yes; then
+      if test "$pic_mode" != yes; then
+	# Don't build PIC code
+	command="$base_compile $qsrcfile"
+      else
+	command="$base_compile $qsrcfile $pic_flag"
+      fi
+      if test "$compiler_c_o" = yes; then
+	command="$command -o $obj"
+      fi
+
+      # Suppress compiler output if we already did a PIC compilation.
+      command="$command$suppress_output"
+      $run $rm "$obj" "$output_obj"
+      $show "$command"
+      if $run eval "$command"; then :
+      else
+	$run $rm $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      if test "$need_locks" = warn &&
+	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
+	$echo "\
+*** ERROR, $lockfile contains:
+`cat $lockfile 2>/dev/null`
+
+but it should contain:
+$srcfile
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support \`-c' and \`-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$run $rm $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      # Just move the object if needed
+      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
+	$show "$mv $output_obj $obj"
+	if $run $mv $output_obj $obj; then :
+	else
+	  error=$?
+	  $run $rm $removelist
+	  exit $error
+	fi
+      fi
+
+      # Append the name of the non-PIC object the libtool object file.
+      # Only append if the libtool object file exists.
+      test -z "$run" && cat >> ${libobj}T <<EOF
+# Name of the non-PIC object.
+non_pic_object='$objname'
+
+EOF
+    else
+      # Append the name of the non-PIC object the libtool object file.
+      # Only append if the libtool object file exists.
+      test -z "$run" && cat >> ${libobj}T <<EOF
+# Name of the non-PIC object.
+non_pic_object=none
+
+EOF
+    fi
+
+    $run $mv "${libobj}T" "${libobj}"
+
+    # Unlock the critical section if it was locked
+    if test "$need_locks" != no; then
+      $run $rm "$lockfile"
+    fi
+
+    exit $EXIT_SUCCESS
+    ;;
+
+  # libtool link mode
+  link | relink)
+    modename="$modename: link"
+    case $host in
+    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
+      # It is impossible to link a dll without this setting, and
+      # we shouldn't force the makefile maintainer to figure out
+      # which system we are compiling for in order to pass an extra
+      # flag for every libtool invocation.
+      # allow_undefined=no
+
+      # FIXME: Unfortunately, there are problems with the above when trying
+      # to make a dll which has undefined symbols, in which case not
+      # even a static library is built.  For now, we need to specify
+      # -no-undefined on the libtool link line when we can be certain
+      # that all symbols are satisfied, otherwise we get a static library.
+      allow_undefined=yes
+      ;;
+    *)
+      allow_undefined=yes
+      ;;
+    esac
+    libtool_args="$nonopt"
+    base_compile="$nonopt $@"
+    compile_command="$nonopt"
+    finalize_command="$nonopt"
+
+    compile_rpath=
+    finalize_rpath=
+    compile_shlibpath=
+    finalize_shlibpath=
+    convenience=
+    old_convenience=
+    deplibs=
+    old_deplibs=
+    compiler_flags=
+    linker_flags=
+    dllsearchpath=
+    lib_search_path=`pwd`
+    inst_prefix_dir=
+
+    avoid_version=no
+    dlfiles=
+    dlprefiles=
+    dlself=no
+    export_dynamic=no
+    export_symbols=
+    export_symbols_regex=
+    generated=
+    libobjs=
+    ltlibs=
+    module=no
+    no_install=no
+    objs=
+    non_pic_objects=
+    notinst_path= # paths that contain not-installed libtool libraries
+    precious_files_regex=
+    prefer_static_libs=no
+    preload=no
+    prev=
+    prevarg=
+    release=
+    rpath=
+    xrpath=
+    perm_rpath=
+    temp_rpath=
+    thread_safe=no
+    vinfo=
+    vinfo_number=no
+
+    func_infer_tag $base_compile
+
+    # We need to know -static, to get the right output filenames.
+    for arg
+    do
+      case $arg in
+      -all-static | -static)
+	if test "X$arg" = "X-all-static"; then
+	  if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
+	    $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
+	  fi
+	  if test -n "$link_static_flag"; then
+	    dlopen_self=$dlopen_self_static
+	  fi
+	  prefer_static_libs=yes
+	else
+	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
+	    dlopen_self=$dlopen_self_static
+	  fi
+	  prefer_static_libs=built
+	fi
+	build_libtool_libs=no
+	build_old_libs=yes
+	break
+	;;
+      esac
+    done
+
+    # See if our shared archives depend on static archives.
+    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
+
+    # Go through the arguments, transforming them on the way.
+    while test "$#" -gt 0; do
+      arg="$1"
+      shift
+      case $arg in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
+	;;
+      *) qarg=$arg ;;
+      esac
+      libtool_args="$libtool_args $qarg"
+
+      # If the previous option needs an argument, assign it.
+      if test -n "$prev"; then
+	case $prev in
+	output)
+	  compile_command="$compile_command @OUTPUT@"
+	  finalize_command="$finalize_command @OUTPUT@"
+	  ;;
+	esac
+
+	case $prev in
+	dlfiles|dlprefiles)
+	  if test "$preload" = no; then
+	    # Add the symbol object into the linking commands.
+	    compile_command="$compile_command @SYMFILE@"
+	    finalize_command="$finalize_command @SYMFILE@"
+	    preload=yes
+	  fi
+	  case $arg in
+	  *.la | *.lo) ;;  # We handle these cases below.
+	  force)
+	    if test "$dlself" = no; then
+	      dlself=needless
+	      export_dynamic=yes
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  self)
+	    if test "$prev" = dlprefiles; then
+	      dlself=yes
+	    elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
+	      dlself=yes
+	    else
+	      dlself=needless
+	      export_dynamic=yes
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  *)
+	    if test "$prev" = dlfiles; then
+	      dlfiles="$dlfiles $arg"
+	    else
+	      dlprefiles="$dlprefiles $arg"
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  esac
+	  ;;
+	expsyms)
+	  export_symbols="$arg"
+	  if test ! -f "$arg"; then
+	    $echo "$modename: symbol file \`$arg' does not exist"
+	    exit $EXIT_FAILURE
+	  fi
+	  prev=
+	  continue
+	  ;;
+	expsyms_regex)
+	  export_symbols_regex="$arg"
+	  prev=
+	  continue
+	  ;;
+	inst_prefix)
+	  inst_prefix_dir="$arg"
+	  prev=
+	  continue
+	  ;;
+	precious_regex)
+	  precious_files_regex="$arg"
+	  prev=
+	  continue
+	  ;;
+	release)
+	  release="-$arg"
+	  prev=
+	  continue
+	  ;;
+	objectlist)
+	  if test -f "$arg"; then
+	    save_arg=$arg
+	    moreargs=
+	    for fil in `cat $save_arg`
+	    do
+#	      moreargs="$moreargs $fil"
+	      arg=$fil
+	      # A libtool-controlled object.
+
+	      # Check to see that this really is a libtool object.
+	      if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+		pic_object=
+		non_pic_object=
+
+		# Read the .lo file
+		# If there is no directory component, then add one.
+		case $arg in
+		*/* | *\\*) . $arg ;;
+		*) . ./$arg ;;
+		esac
+
+		if test -z "$pic_object" || \
+		   test -z "$non_pic_object" ||
+		   test "$pic_object" = none && \
+		   test "$non_pic_object" = none; then
+		  $echo "$modename: cannot find name of object for \`$arg'" 1>&2
+		  exit $EXIT_FAILURE
+		fi
+
+		# Extract subdirectory from the argument.
+		xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
+		if test "X$xdir" = "X$arg"; then
+		  xdir=
+		else
+		  xdir="$xdir/"
+		fi
+
+		if test "$pic_object" != none; then
+		  # Prepend the subdirectory the object is found in.
+		  pic_object="$xdir$pic_object"
+
+		  if test "$prev" = dlfiles; then
+		    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
+		      dlfiles="$dlfiles $pic_object"
+		      prev=
+		      continue
+		    else
+		      # If libtool objects are unsupported, then we need to preload.
+		      prev=dlprefiles
+		    fi
+		  fi
+
+		  # CHECK ME:  I think I busted this.  -Ossama
+		  if test "$prev" = dlprefiles; then
+		    # Preload the old-style object.
+		    dlprefiles="$dlprefiles $pic_object"
+		    prev=
+		  fi
+
+		  # A PIC object.
+		  libobjs="$libobjs $pic_object"
+		  arg="$pic_object"
+		fi
+
+		# Non-PIC object.
+		if test "$non_pic_object" != none; then
+		  # Prepend the subdirectory the object is found in.
+		  non_pic_object="$xdir$non_pic_object"
+
+		  # A standard non-PIC object
+		  non_pic_objects="$non_pic_objects $non_pic_object"
+		  if test -z "$pic_object" || test "$pic_object" = none ; then
+		    arg="$non_pic_object"
+		  fi
+		else
+		  # If the PIC object exists, use it instead.
+		  # $xdir was prepended to $pic_object above.
+		  non_pic_object="$pic_object"
+		  non_pic_objects="$non_pic_objects $non_pic_object"
+		fi
+	      else
+		# Only an error if not doing a dry-run.
+		if test -z "$run"; then
+		  $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
+		  exit $EXIT_FAILURE
+		else
+		  # Dry-run case.
+
+		  # Extract subdirectory from the argument.
+		  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
+		  if test "X$xdir" = "X$arg"; then
+		    xdir=
+		  else
+		    xdir="$xdir/"
+		  fi
+
+		  pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
+		  non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
+		  libobjs="$libobjs $pic_object"
+		  non_pic_objects="$non_pic_objects $non_pic_object"
+		fi
+	      fi
+	    done
+	  else
+	    $echo "$modename: link input file \`$save_arg' does not exist"
+	    exit $EXIT_FAILURE
+	  fi
+	  arg=$save_arg
+	  prev=
+	  continue
+	  ;;
+	rpath | xrpath)
+	  # We need an absolute path.
+	  case $arg in
+	  [\\/]* | [A-Za-z]:[\\/]*) ;;
+	  *)
+	    $echo "$modename: only absolute run-paths are allowed" 1>&2
+	    exit $EXIT_FAILURE
+	    ;;
+	  esac
+	  if test "$prev" = rpath; then
+	    case "$rpath " in
+	    *" $arg "*) ;;
+	    *) rpath="$rpath $arg" ;;
+	    esac
+	  else
+	    case "$xrpath " in
+	    *" $arg "*) ;;
+	    *) xrpath="$xrpath $arg" ;;
+	    esac
+	  fi
+	  prev=
+	  continue
+	  ;;
+	xcompiler)
+	  compiler_flags="$compiler_flags $qarg"
+	  prev=
+	  compile_command="$compile_command $qarg"
+	  finalize_command="$finalize_command $qarg"
+	  continue
+	  ;;
+	xlinker)
+	  linker_flags="$linker_flags $qarg"
+	  compiler_flags="$compiler_flags $wl$qarg"
+	  prev=
+	  compile_command="$compile_command $wl$qarg"
+	  finalize_command="$finalize_command $wl$qarg"
+	  continue
+	  ;;
+	xcclinker)
+	  linker_flags="$linker_flags $qarg"
+	  compiler_flags="$compiler_flags $qarg"
+	  prev=
+	  compile_command="$compile_command $qarg"
+	  finalize_command="$finalize_command $qarg"
+	  continue
+	  ;;
+	shrext)
+  	  shrext_cmds="$arg"
+	  prev=
+	  continue
+	  ;;
+	darwin_framework|darwin_framework_skip)
+	  test "$prev" = "darwin_framework" && compiler_flags="$compiler_flags $arg"
+	  compile_command="$compile_command $arg"
+	  finalize_command="$finalize_command $arg"
+	  prev=
+	  continue
+	  ;;
+	*)
+	  eval "$prev=\"\$arg\""
+	  prev=
+	  continue
+	  ;;
+	esac
+      fi # test -n "$prev"
+
+      prevarg="$arg"
+
+      case $arg in
+      -all-static)
+	if test -n "$link_static_flag"; then
+	  compile_command="$compile_command $link_static_flag"
+	  finalize_command="$finalize_command $link_static_flag"
+	fi
+	continue
+	;;
+
+      -allow-undefined)
+	# FIXME: remove this flag sometime in the future.
+	$echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
+	continue
+	;;
+
+      -avoid-version)
+	avoid_version=yes
+	continue
+	;;
+
+      -dlopen)
+	prev=dlfiles
+	continue
+	;;
+
+      -dlpreopen)
+	prev=dlprefiles
+	continue
+	;;
+
+      -export-dynamic)
+	export_dynamic=yes
+	continue
+	;;
+
+      -export-symbols | -export-symbols-regex)
+	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
+	  $echo "$modename: more than one -exported-symbols argument is not allowed"
+	  exit $EXIT_FAILURE
+	fi
+	if test "X$arg" = "X-export-symbols"; then
+	  prev=expsyms
+	else
+	  prev=expsyms_regex
+	fi
+	continue
+	;;
+
+      -framework|-arch|-isysroot)
+	case " $CC " in
+	  *" ${arg} ${1} "* | *" ${arg}	${1} "*) 
+		prev=darwin_framework_skip ;;
+	  *) compiler_flags="$compiler_flags $arg"
+	     prev=darwin_framework ;;
+	esac
+	compile_command="$compile_command $arg"
+	finalize_command="$finalize_command $arg"
+	continue
+	;;
+
+      -inst-prefix-dir)
+	prev=inst_prefix
+	continue
+	;;
+
+      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
+      # so, if we see these flags be careful not to treat them like -L
+      -L[A-Z][A-Z]*:*)
+	case $with_gcc/$host in
+	no/*-*-irix* | /*-*-irix*)
+	  compile_command="$compile_command $arg"
+	  finalize_command="$finalize_command $arg"
+	  ;;
+	esac
+	continue
+	;;
+
+      -L*)
+	dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
+	# We need an absolute path.
+	case $dir in
+	[\\/]* | [A-Za-z]:[\\/]*) ;;
+	*)
+	  absdir=`cd "$dir" && pwd`
+	  if test -z "$absdir"; then
+	    $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
+	    absdir="$dir"
+	    notinst_path="$notinst_path $dir"
+	  fi
+	  dir="$absdir"
+	  ;;
+	esac
+	case "$deplibs " in
+	*" -L$dir "*) ;;
+	*)
+	  deplibs="$deplibs -L$dir"
+	  lib_search_path="$lib_search_path $dir"
+	  ;;
+	esac
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
+	  testbindir=`$echo "X$dir" | $Xsed -e 's*/lib$*/bin*'`
+	  case :$dllsearchpath: in
+	  *":$dir:"*) ;;
+	  *) dllsearchpath="$dllsearchpath:$dir";;
+	  esac
+	  case :$dllsearchpath: in
+	  *":$testbindir:"*) ;;
+	  *) dllsearchpath="$dllsearchpath:$testbindir";;
+	  esac
+	  ;;
+	esac
+	continue
+	;;
+
+      -l*)
+	if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
+	  case $host in
+	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos*)
+	    # These systems don't actually have a C or math library (as such)
+	    continue
+	    ;;
+	  *-*-os2*)
+	    # These systems don't actually have a C library (as such)
+	    test "X$arg" = "X-lc" && continue
+	    ;;
+	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+	    # Do not include libc due to us having libc/libc_r.
+	    test "X$arg" = "X-lc" && continue
+	    ;;
+	  *-*-rhapsody* | *-*-darwin1.[012])
+	    # Rhapsody C and math libraries are in the System framework
+	    deplibs="$deplibs -framework System"
+	    continue
+	    ;;
+	  *-*-sco3.2v5* | *-*-sco5v6*)
+	    # Causes problems with __ctype
+	    test "X$arg" = "X-lc" && continue
+	    ;;
+	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
+	    # Compiler inserts libc in the correct place for threads to work
+	    test "X$arg" = "X-lc" && continue
+	    ;;
+	  esac
+	elif test "X$arg" = "X-lc_r"; then
+	 case $host in
+	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+	   # Do not include libc_r directly, use -pthread flag.
+	   continue
+	   ;;
+	 esac
+	fi
+	deplibs="$deplibs $arg"
+	continue
+	;;
+
+      # Tru64 UNIX uses -model [arg] to determine the layout of C++
+      # classes, name mangling, and exception handling.
+      -model)
+	compile_command="$compile_command $arg"
+	compiler_flags="$compiler_flags $arg"
+	finalize_command="$finalize_command $arg"
+	prev=xcompiler
+	continue
+	;;
+
+     -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
+	compiler_flags="$compiler_flags $arg"
+	compile_command="$compile_command $arg"
+	finalize_command="$finalize_command $arg"
+	continue
+	;;
+
+      -module)
+	module=yes
+	continue
+	;;
+
+      # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
+      # -r[0-9][0-9]* specifies the processor on the SGI compiler
+      # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
+      # +DA*, +DD* enable 64-bit mode on the HP compiler
+      # -q* pass through compiler args for the IBM compiler
+      # -m* pass through architecture-specific compiler args for GCC
+      # -m*, -t[45]*, -txscale* pass through architecture-specific
+      # compiler args for GCC
+      # -pg pass through profiling flag for GCC
+      # @file GCC response files
+      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*|-pg| \
+      -t[45]*|-txscale*|@*)
+
+	# Unknown arguments in both finalize_command and compile_command need
+	# to be aesthetically quoted because they are evaled later.
+	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+	case $arg in
+	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	  arg="\"$arg\""
+	  ;;
+	esac
+        compile_command="$compile_command $arg"
+        finalize_command="$finalize_command $arg"
+        compiler_flags="$compiler_flags $arg"
+        continue
+        ;;
+
+      -shrext)
+	prev=shrext
+	continue
+	;;
+
+      -no-fast-install)
+	fast_install=no
+	continue
+	;;
+
+      -no-install)
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
+	  # The PATH hackery in wrapper scripts is required on Windows
+	  # in order for the loader to find any dlls it needs.
+	  $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
+	  $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
+	  fast_install=no
+	  ;;
+	*) no_install=yes ;;
+	esac
+	continue
+	;;
+
+      -no-undefined)
+	allow_undefined=no
+	continue
+	;;
+
+      -objectlist)
+	prev=objectlist
+	continue
+	;;
+
+      -o) prev=output ;;
+
+      -precious-files-regex)
+	prev=precious_regex
+	continue
+	;;
+
+      -release)
+	prev=release
+	continue
+	;;
+
+      -rpath)
+	prev=rpath
+	continue
+	;;
+
+      -R)
+	prev=xrpath
+	continue
+	;;
+
+      -R*)
+	dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
+	# We need an absolute path.
+	case $dir in
+	[\\/]* | [A-Za-z]:[\\/]*) ;;
+	*)
+	  $echo "$modename: only absolute run-paths are allowed" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+	case "$xrpath " in
+	*" $dir "*) ;;
+	*) xrpath="$xrpath $dir" ;;
+	esac
+	continue
+	;;
+
+      -static)
+	# The effects of -static are defined in a previous loop.
+	# We used to do the same as -all-static on platforms that
+	# didn't have a PIC flag, but the assumption that the effects
+	# would be equivalent was wrong.  It would break on at least
+	# Digital Unix and AIX.
+	continue
+	;;
+
+      -thread-safe)
+	thread_safe=yes
+	continue
+	;;
+
+      -version-info)
+	prev=vinfo
+	continue
+	;;
+      -version-number)
+	prev=vinfo
+	vinfo_number=yes
+	continue
+	;;
+
+      -Wc,*)
+	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
+	arg=
+	save_ifs="$IFS"; IFS=','
+	for flag in $args; do
+	  IFS="$save_ifs"
+	  case $flag in
+	    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	    flag="\"$flag\""
+	    ;;
+	  esac
+	  arg="$arg $wl$flag"
+	  compiler_flags="$compiler_flags $flag"
+	done
+	IFS="$save_ifs"
+	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
+	;;
+
+      -Wl,*)
+	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
+	arg=
+	save_ifs="$IFS"; IFS=','
+	for flag in $args; do
+	  IFS="$save_ifs"
+	  case $flag in
+	    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	    flag="\"$flag\""
+	    ;;
+	  esac
+	  arg="$arg $wl$flag"
+	  compiler_flags="$compiler_flags $wl$flag"
+	  linker_flags="$linker_flags $flag"
+	done
+	IFS="$save_ifs"
+	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
+	;;
+
+      -Xcompiler)
+	prev=xcompiler
+	continue
+	;;
+
+      -Xlinker)
+	prev=xlinker
+	continue
+	;;
+
+      -XCClinker)
+	prev=xcclinker
+	continue
+	;;
+
+      # Some other compiler flag.
+      -* | +*)
+	# Unknown arguments in both finalize_command and compile_command need
+	# to be aesthetically quoted because they are evaled later.
+	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+	case $arg in
+	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	  arg="\"$arg\""
+	  ;;
+	esac
+	;;
+
+      *.$objext)
+	# A standard object.
+	objs="$objs $arg"
+	;;
+
+      *.lo)
+	# A libtool-controlled object.
+
+	# Check to see that this really is a libtool object.
+	if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+	  pic_object=
+	  non_pic_object=
+
+	  # Read the .lo file
+	  # If there is no directory component, then add one.
+	  case $arg in
+	  */* | *\\*) . $arg ;;
+	  *) . ./$arg ;;
+	  esac
+
+	  if test -z "$pic_object" || \
+	     test -z "$non_pic_object" ||
+	     test "$pic_object" = none && \
+	     test "$non_pic_object" = none; then
+	    $echo "$modename: cannot find name of object for \`$arg'" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+
+	  # Extract subdirectory from the argument.
+	  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
+	  if test "X$xdir" = "X$arg"; then
+	    xdir=
+ 	  else
+	    xdir="$xdir/"
+	  fi
+
+	  if test "$pic_object" != none; then
+	    # Prepend the subdirectory the object is found in.
+	    pic_object="$xdir$pic_object"
+
+	    if test "$prev" = dlfiles; then
+	      if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
+		dlfiles="$dlfiles $pic_object"
+		prev=
+		continue
+	      else
+		# If libtool objects are unsupported, then we need to preload.
+		prev=dlprefiles
+	      fi
+	    fi
+
+	    # CHECK ME:  I think I busted this.  -Ossama
+	    if test "$prev" = dlprefiles; then
+	      # Preload the old-style object.
+	      dlprefiles="$dlprefiles $pic_object"
+	      prev=
+	    fi
+
+	    # A PIC object.
+	    libobjs="$libobjs $pic_object"
+	    arg="$pic_object"
+	  fi
+
+	  # Non-PIC object.
+	  if test "$non_pic_object" != none; then
+	    # Prepend the subdirectory the object is found in.
+	    non_pic_object="$xdir$non_pic_object"
+
+	    # A standard non-PIC object
+	    non_pic_objects="$non_pic_objects $non_pic_object"
+	    if test -z "$pic_object" || test "$pic_object" = none ; then
+	      arg="$non_pic_object"
+	    fi
+	  else
+	    # If the PIC object exists, use it instead.
+	    # $xdir was prepended to $pic_object above.
+	    non_pic_object="$pic_object"
+	    non_pic_objects="$non_pic_objects $non_pic_object"
+	  fi
+	else
+	  # Only an error if not doing a dry-run.
+	  if test -z "$run"; then
+	    $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
+	    exit $EXIT_FAILURE
+	  else
+	    # Dry-run case.
+
+	    # Extract subdirectory from the argument.
+	    xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
+	    if test "X$xdir" = "X$arg"; then
+	      xdir=
+	    else
+	      xdir="$xdir/"
+	    fi
+
+	    pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
+	    non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
+	    libobjs="$libobjs $pic_object"
+	    non_pic_objects="$non_pic_objects $non_pic_object"
+	  fi
+	fi
+	;;
+
+      *.$libext)
+	# An archive.
+	deplibs="$deplibs $arg"
+	old_deplibs="$old_deplibs $arg"
+	continue
+	;;
+
+      *.la)
+	# A libtool-controlled library.
+
+	if test "$prev" = dlfiles; then
+	  # This library was specified with -dlopen.
+	  dlfiles="$dlfiles $arg"
+	  prev=
+	elif test "$prev" = dlprefiles; then
+	  # The library was specified with -dlpreopen.
+	  dlprefiles="$dlprefiles $arg"
+	  prev=
+	else
+	  deplibs="$deplibs $arg"
+	fi
+	continue
+	;;
+
+      # Some other compiler argument.
+      *)
+	# Unknown arguments in both finalize_command and compile_command need
+	# to be aesthetically quoted because they are evaled later.
+	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+	case $arg in
+	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	  arg="\"$arg\""
+	  ;;
+	esac
+	;;
+      esac # arg
+
+      # Now actually substitute the argument into the commands.
+      if test -n "$arg"; then
+	compile_command="$compile_command $arg"
+	finalize_command="$finalize_command $arg"
+      fi
+    done # argument parsing loop
+
+    if test -n "$prev"; then
+      $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
+      eval arg=\"$export_dynamic_flag_spec\"
+      compile_command="$compile_command $arg"
+      finalize_command="$finalize_command $arg"
+    fi
+
+    oldlibs=
+    # calculate the name of the file, without its directory
+    outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
+    libobjs_save="$libobjs"
+
+    if test -n "$shlibpath_var"; then
+      # get the directories listed in $shlibpath_var
+      eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
+    else
+      shlib_search_path=
+    fi
+    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
+    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
+
+    output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
+    if test "X$output_objdir" = "X$output"; then
+      output_objdir="$objdir"
+    else
+      output_objdir="$output_objdir/$objdir"
+    fi
+    # Create the object directory.
+    if test ! -d "$output_objdir"; then
+      $show "$mkdir $output_objdir"
+      $run $mkdir $output_objdir
+      exit_status=$?
+      if test "$exit_status" -ne 0 && test ! -d "$output_objdir"; then
+	exit $exit_status
+      fi
+    fi
+
+    # Determine the type of output
+    case $output in
+    "")
+      $echo "$modename: you must specify an output file" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+      ;;
+    *.$libext) linkmode=oldlib ;;
+    *.lo | *.$objext) linkmode=obj ;;
+    *.la) linkmode=lib ;;
+    *) linkmode=prog ;; # Anything else should be a program.
+    esac
+
+    case $host in
+    *cygwin* | *mingw* | *pw32*)
+      # don't eliminate duplications in $postdeps and $predeps
+      duplicate_compiler_generated_deps=yes
+      ;;
+    *)
+      duplicate_compiler_generated_deps=$duplicate_deps
+      ;;
+    esac
+    specialdeplibs=
+
+    libs=
+    # Find all interdependent deplibs by searching for libraries
+    # that are linked more than once (e.g. -la -lb -la)
+    for deplib in $deplibs; do
+      if test "X$duplicate_deps" = "Xyes" ; then
+	case "$libs " in
+	*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
+	esac
+      fi
+      libs="$libs $deplib"
+    done
+
+    if test "$linkmode" = lib; then
+      libs="$predeps $libs $compiler_lib_search_path $postdeps"
+
+      # Compute libraries that are listed more than once in $predeps
+      # $postdeps and mark them as special (i.e., whose duplicates are
+      # not to be eliminated).
+      pre_post_deps=
+      if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
+	for pre_post_dep in $predeps $postdeps; do
+	  case "$pre_post_deps " in
+	  *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
+	  esac
+	  pre_post_deps="$pre_post_deps $pre_post_dep"
+	done
+      fi
+      pre_post_deps=
+    fi
+
+    deplibs=
+    newdependency_libs=
+    newlib_search_path=
+    need_relink=no # whether we're linking any uninstalled libtool libraries
+    notinst_deplibs= # not-installed libtool libraries
+    case $linkmode in
+    lib)
+	passes="conv link"
+	for file in $dlfiles $dlprefiles; do
+	  case $file in
+	  *.la) ;;
+	  *)
+	    $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
+	    exit $EXIT_FAILURE
+	    ;;
+	  esac
+	done
+	;;
+    prog)
+	compile_deplibs=
+	finalize_deplibs=
+	alldeplibs=no
+	newdlfiles=
+	newdlprefiles=
+	passes="conv scan dlopen dlpreopen link"
+	;;
+    *)  passes="conv"
+	;;
+    esac
+    for pass in $passes; do
+      if test "$linkmode,$pass" = "lib,link" ||
+	 test "$linkmode,$pass" = "prog,scan"; then
+	libs="$deplibs"
+	deplibs=
+      fi
+      if test "$linkmode" = prog; then
+	case $pass in
+	dlopen) libs="$dlfiles" ;;
+	dlpreopen) libs="$dlprefiles" ;;
+	link)
+	  libs="$deplibs %DEPLIBS%"
+	  test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
+	  ;;
+	esac
+      fi
+      if test "$pass" = dlopen; then
+	# Collect dlpreopened libraries
+	save_deplibs="$deplibs"
+	deplibs=
+      fi
+      for deplib in $libs; do
+	lib=
+	found=no
+	case $deplib in
+	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
+	  if test "$linkmode,$pass" = "prog,link"; then
+	    compile_deplibs="$deplib $compile_deplibs"
+	    finalize_deplibs="$deplib $finalize_deplibs"
+	  else
+	    compiler_flags="$compiler_flags $deplib"
+	  fi
+	  continue
+	  ;;
+	-l*)
+	  if test "$linkmode" != lib && test "$linkmode" != prog; then
+	    $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
+	    continue
+	  fi
+	  name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
+	  for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
+	    for search_ext in .la $std_shrext .so .a; do
+	      # Search the libtool library
+	      lib="$searchdir/lib${name}${search_ext}"
+	      if test -f "$lib"; then
+		if test "$search_ext" = ".la"; then
+		  found=yes
+		else
+		  found=no
+		fi
+		break 2
+	      fi
+	    done
+	  done
+	  if test "$found" != yes; then
+	    # deplib doesn't seem to be a libtool library
+	    if test "$linkmode,$pass" = "prog,link"; then
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    else
+	      deplibs="$deplib $deplibs"
+	      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
+	    fi
+	    continue
+	  else # deplib is a libtool library
+	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
+	    # We need to do some special things here, and not later.
+	    if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+	      case " $predeps $postdeps " in
+	      *" $deplib "*)
+		if (${SED} -e '2q' $lib |
+                    grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+		  library_names=
+		  old_library=
+		  case $lib in
+		  */* | *\\*) . $lib ;;
+		  *) . ./$lib ;;
+		  esac
+		  for l in $old_library $library_names; do
+		    ll="$l"
+		  done
+		  if test "X$ll" = "X$old_library" ; then # only static version available
+		    found=no
+		    ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
+		    test "X$ladir" = "X$lib" && ladir="."
+		    lib=$ladir/$old_library
+		    if test "$linkmode,$pass" = "prog,link"; then
+		      compile_deplibs="$deplib $compile_deplibs"
+		      finalize_deplibs="$deplib $finalize_deplibs"
+		    else
+		      deplibs="$deplib $deplibs"
+		      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
+		    fi
+		    continue
+		  fi
+		fi
+	        ;;
+	      *) ;;
+	      esac
+	    fi
+	  fi
+	  ;; # -l
+	-L*)
+	  case $linkmode in
+	  lib)
+	    deplibs="$deplib $deplibs"
+	    test "$pass" = conv && continue
+	    newdependency_libs="$deplib $newdependency_libs"
+	    newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
+	    ;;
+	  prog)
+	    if test "$pass" = conv; then
+	      deplibs="$deplib $deplibs"
+	      continue
+	    fi
+	    if test "$pass" = scan; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    fi
+	    newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
+	    ;;
+	  *)
+	    $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
+	    ;;
+	  esac # linkmode
+	  continue
+	  ;; # -L
+	-R*)
+	  if test "$pass" = link; then
+	    dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
+	    # Make sure the xrpath contains only unique directories.
+	    case "$xrpath " in
+	    *" $dir "*) ;;
+	    *) xrpath="$xrpath $dir" ;;
+	    esac
+	  fi
+	  deplibs="$deplib $deplibs"
+	  continue
+	  ;;
+	*.la) lib="$deplib" ;;
+	*.$libext)
+	  if test "$pass" = conv; then
+	    deplibs="$deplib $deplibs"
+	    continue
+	  fi
+	  case $linkmode in
+	  lib)
+	    valid_a_lib=no
+	    case $deplibs_check_method in
+	      match_pattern*)
+		set dummy $deplibs_check_method
+	        match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
+		if eval $echo \"$deplib\" 2>/dev/null \
+		    | $SED 10q \
+		    | $EGREP "$match_pattern_regex" > /dev/null; then
+		  valid_a_lib=yes
+		fi
+		;;
+	      pass_all)
+		valid_a_lib=yes
+		;;
+            esac
+	    if test "$valid_a_lib" != yes; then
+	      $echo
+	      $echo "*** Warning: Trying to link with static lib archive $deplib."
+	      $echo "*** I have the capability to make that library automatically link in when"
+	      $echo "*** you link to this library.  But I can only do this if you have a"
+	      $echo "*** shared version of the library, which you do not appear to have"
+	      $echo "*** because the file extensions .$libext of this argument makes me believe"
+	      $echo "*** that it is just a static archive that I should not used here."
+	    else
+	      $echo
+	      $echo "*** Warning: Linking the shared library $output against the"
+	      $echo "*** static library $deplib is not portable!"
+	      deplibs="$deplib $deplibs"
+	    fi
+	    continue
+	    ;;
+	  prog)
+	    if test "$pass" != link; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    fi
+	    continue
+	    ;;
+	  esac # linkmode
+	  ;; # *.$libext
+	*.lo | *.$objext)
+	  if test "$pass" = conv; then
+	    deplibs="$deplib $deplibs"
+	  elif test "$linkmode" = prog; then
+	    if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
+	      # If there is no dlopen support or we're linking statically,
+	      # we need to preload.
+	      newdlprefiles="$newdlprefiles $deplib"
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    else
+	      newdlfiles="$newdlfiles $deplib"
+	    fi
+	  fi
+	  continue
+	  ;;
+	%DEPLIBS%)
+	  alldeplibs=yes
+	  continue
+	  ;;
+	esac # case $deplib
+	if test "$found" = yes || test -f "$lib"; then :
+	else
+	  $echo "$modename: cannot find the library \`$lib' or unhandled argument \`$deplib'" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	# Check to see that this really is a libtool archive.
+	if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
+	else
+	  $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
+	test "X$ladir" = "X$lib" && ladir="."
+
+	dlname=
+	dlopen=
+	dlpreopen=
+	libdir=
+	library_names=
+	old_library=
+	# If the library was installed with an old release of libtool,
+	# it will not redefine variables installed, or shouldnotlink
+	installed=yes
+	shouldnotlink=no
+	avoidtemprpath=
+
+
+	# Read the .la file
+	case $lib in
+	*/* | *\\*) . $lib ;;
+	*) . ./$lib ;;
+	esac
+
+	if test "$linkmode,$pass" = "lib,link" ||
+	   test "$linkmode,$pass" = "prog,scan" ||
+	   { test "$linkmode" != prog && test "$linkmode" != lib; }; then
+	  test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
+	  test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
+	fi
+
+	if test "$pass" = conv; then
+	  # Only check for convenience libraries
+	  deplibs="$lib $deplibs"
+	  if test -z "$libdir"; then
+	    if test -z "$old_library"; then
+	      $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
+	      exit $EXIT_FAILURE
+	    fi
+	    # It is a libtool convenience library, so add in its objects.
+	    convenience="$convenience $ladir/$objdir/$old_library"
+	    old_convenience="$old_convenience $ladir/$objdir/$old_library"
+	    tmp_libs=
+	    for deplib in $dependency_libs; do
+	      deplibs="$deplib $deplibs"
+              if test "X$duplicate_deps" = "Xyes" ; then
+	        case "$tmp_libs " in
+	        *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
+	        esac
+              fi
+	      tmp_libs="$tmp_libs $deplib"
+	    done
+	  elif test "$linkmode" != prog && test "$linkmode" != lib; then
+	    $echo "$modename: \`$lib' is not a convenience library" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+	  continue
+	fi # $pass = conv
+
+
+	# Get the name of the library we link against.
+	linklib=
+	for l in $old_library $library_names; do
+	  linklib="$l"
+	done
+	if test -z "$linklib"; then
+	  $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	# This library was specified with -dlopen.
+	if test "$pass" = dlopen; then
+	  if test -z "$libdir"; then
+	    $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+	  if test -z "$dlname" ||
+	     test "$dlopen_support" != yes ||
+	     test "$build_libtool_libs" = no; then
+	    # If there is no dlname, no dlopen support or we're linking
+	    # statically, we need to preload.  We also need to preload any
+	    # dependent libraries so libltdl's deplib preloader doesn't
+	    # bomb out in the load deplibs phase.
+	    dlprefiles="$dlprefiles $lib $dependency_libs"
+	  else
+	    newdlfiles="$newdlfiles $lib"
+	  fi
+	  continue
+	fi # $pass = dlopen
+
+	# We need an absolute path.
+	case $ladir in
+	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
+	*)
+	  abs_ladir=`cd "$ladir" && pwd`
+	  if test -z "$abs_ladir"; then
+	    $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
+	    $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
+	    abs_ladir="$ladir"
+	  fi
+	  ;;
+	esac
+	laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
+
+	# Find the relevant object directory and library name.
+	if test "X$installed" = Xyes; then
+	  if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
+	    $echo "$modename: warning: library \`$lib' was moved." 1>&2
+	    dir="$ladir"
+	    absdir="$abs_ladir"
+	    libdir="$abs_ladir"
+	  else
+	    dir="$libdir"
+	    absdir="$libdir"
+	  fi
+	  test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
+	else
+	  if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
+	    dir="$ladir"
+	    absdir="$abs_ladir"
+	    # Remove this search path later
+	    notinst_path="$notinst_path $abs_ladir"
+	  else
+	    dir="$ladir/$objdir"
+	    absdir="$abs_ladir/$objdir"
+	    # Remove this search path later
+	    notinst_path="$notinst_path $abs_ladir"
+	  fi
+	fi # $installed = yes
+	name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
+
+	# This library was specified with -dlpreopen.
+	if test "$pass" = dlpreopen; then
+	  if test -z "$libdir"; then
+	    $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+	  # Prefer using a static library (so that no silly _DYNAMIC symbols
+	  # are required to link).
+	  if test -n "$old_library"; then
+	    newdlprefiles="$newdlprefiles $dir/$old_library"
+	  # Otherwise, use the dlname, so that lt_dlopen finds it.
+	  elif test -n "$dlname"; then
+	    newdlprefiles="$newdlprefiles $dir/$dlname"
+	  else
+	    newdlprefiles="$newdlprefiles $dir/$linklib"
+	  fi
+	fi # $pass = dlpreopen
+
+	if test -z "$libdir"; then
+	  # Link the convenience library
+	  if test "$linkmode" = lib; then
+	    deplibs="$dir/$old_library $deplibs"
+	  elif test "$linkmode,$pass" = "prog,link"; then
+	    compile_deplibs="$dir/$old_library $compile_deplibs"
+	    finalize_deplibs="$dir/$old_library $finalize_deplibs"
+	  else
+	    deplibs="$lib $deplibs" # used for prog,scan pass
+	  fi
+	  continue
+	fi
+
+
+	if test "$linkmode" = prog && test "$pass" != link; then
+	  newlib_search_path="$newlib_search_path $ladir"
+	  deplibs="$lib $deplibs"
+
+	  linkalldeplibs=no
+	  if test "$link_all_deplibs" != no || test -z "$library_names" ||
+	     test "$build_libtool_libs" = no; then
+	    linkalldeplibs=yes
+	  fi
+
+	  tmp_libs=
+	  for deplib in $dependency_libs; do
+	    case $deplib in
+	    -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
+	    esac
+	    # Need to link against all dependency_libs?
+	    if test "$linkalldeplibs" = yes; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      # Need to hardcode shared library paths
+	      # or/and link against static libraries
+	      newdependency_libs="$deplib $newdependency_libs"
+	    fi
+	    if test "X$duplicate_deps" = "Xyes" ; then
+	      case "$tmp_libs " in
+	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
+	      esac
+	    fi
+	    tmp_libs="$tmp_libs $deplib"
+	  done # for deplib
+	  continue
+	fi # $linkmode = prog...
+
+	if test "$linkmode,$pass" = "prog,link"; then
+	  if test -n "$library_names" &&
+	     { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
+	    # We need to hardcode the library path
+	    if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
+	      # Make sure the rpath contains only unique directories.
+	      case "$temp_rpath " in
+	      *" $dir "*) ;;
+	      *" $absdir "*) ;;
+	      *) temp_rpath="$temp_rpath $absdir" ;;
+	      esac
+	    fi
+
+	    # Hardcode the library path.
+	    # Skip directories that are in the system default run-time
+	    # search path.
+	    case " $sys_lib_dlsearch_path " in
+	    *" $absdir "*) ;;
+	    *)
+	      case "$compile_rpath " in
+	      *" $absdir "*) ;;
+	      *) compile_rpath="$compile_rpath $absdir"
+	      esac
+	      ;;
+	    esac
+	    case " $sys_lib_dlsearch_path " in
+	    *" $libdir "*) ;;
+	    *)
+	      case "$finalize_rpath " in
+	      *" $libdir "*) ;;
+	      *) finalize_rpath="$finalize_rpath $libdir"
+	      esac
+	      ;;
+	    esac
+	  fi # $linkmode,$pass = prog,link...
+
+	  if test "$alldeplibs" = yes &&
+	     { test "$deplibs_check_method" = pass_all ||
+	       { test "$build_libtool_libs" = yes &&
+		 test -n "$library_names"; }; }; then
+	    # We only need to search for static libraries
+	    continue
+	  fi
+	fi
+
+	link_static=no # Whether the deplib will be linked statically
+	use_static_libs=$prefer_static_libs
+	if test "$use_static_libs" = built && test "$installed" = yes ; then
+	  use_static_libs=no
+	fi
+	if test -n "$library_names" &&
+	   { test "$use_static_libs" = no || test -z "$old_library"; }; then
+	  if test "$installed" = no; then
+	    notinst_deplibs="$notinst_deplibs $lib"
+	    need_relink=yes
+	  fi
+	  # This is a shared library
+
+	  # Warn about portability, can't link against -module's on
+	  # some systems (darwin)
+	  if test "$shouldnotlink" = yes && test "$pass" = link ; then
+	    $echo
+	    if test "$linkmode" = prog; then
+	      $echo "*** Warning: Linking the executable $output against the loadable module"
+	    else
+	      $echo "*** Warning: Linking the shared library $output against the loadable module"
+	    fi
+	    $echo "*** $linklib is not portable!"
+	  fi
+	  if test "$linkmode" = lib &&
+	     test "$hardcode_into_libs" = yes; then
+	    # Hardcode the library path.
+	    # Skip directories that are in the system default run-time
+	    # search path.
+	    case " $sys_lib_dlsearch_path " in
+	    *" $absdir "*) ;;
+	    *)
+	      case "$compile_rpath " in
+	      *" $absdir "*) ;;
+	      *) compile_rpath="$compile_rpath $absdir"
+	      esac
+	      ;;
+	    esac
+	    case " $sys_lib_dlsearch_path " in
+	    *" $libdir "*) ;;
+	    *)
+	      case "$finalize_rpath " in
+	      *" $libdir "*) ;;
+	      *) finalize_rpath="$finalize_rpath $libdir"
+	      esac
+	      ;;
+	    esac
+	  fi
+
+	  if test -n "$old_archive_from_expsyms_cmds"; then
+	    # figure out the soname
+	    set dummy $library_names
+	    realname="$2"
+	    shift; shift
+	    libname=`eval \\$echo \"$libname_spec\"`
+	    # use dlname if we got it. it's perfectly good, no?
+	    if test -n "$dlname"; then
+	      soname="$dlname"
+	    elif test -n "$soname_spec"; then
+	      # bleh windows
+	      case $host in
+	      *cygwin* | mingw*)
+		major=`expr $current - $age`
+		versuffix="-$major"
+		;;
+	      esac
+	      eval soname=\"$soname_spec\"
+	    else
+	      soname="$realname"
+	    fi
+
+	    # Make a new name for the extract_expsyms_cmds to use
+	    soroot="$soname"
+	    soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
+	    newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
+
+	    # If the library has no export list, then create one now
+	    if test -f "$output_objdir/$soname-def"; then :
+	    else
+	      $show "extracting exported symbol list from \`$soname'"
+	      save_ifs="$IFS"; IFS='~'
+	      cmds=$extract_expsyms_cmds
+	      for cmd in $cmds; do
+		IFS="$save_ifs"
+		eval cmd=\"$cmd\"
+		$show "$cmd"
+		$run eval "$cmd" || exit $?
+	      done
+	      IFS="$save_ifs"
+	    fi
+
+	    # Create $newlib
+	    if test -f "$output_objdir/$newlib"; then :; else
+	      $show "generating import library for \`$soname'"
+	      save_ifs="$IFS"; IFS='~'
+	      cmds=$old_archive_from_expsyms_cmds
+	      for cmd in $cmds; do
+		IFS="$save_ifs"
+		eval cmd=\"$cmd\"
+		$show "$cmd"
+		$run eval "$cmd" || exit $?
+	      done
+	      IFS="$save_ifs"
+	    fi
+	    # make sure the library variables are pointing to the new library
+	    dir=$output_objdir
+	    linklib=$newlib
+	  fi # test -n "$old_archive_from_expsyms_cmds"
+
+	  if test "$linkmode" = prog || test "$mode" != relink; then
+	    add_shlibpath=
+	    add_dir=
+	    add=
+	    lib_linked=yes
+	    case $hardcode_action in
+	    immediate | unsupported)
+	      if test "$hardcode_direct" = no; then
+		add="$dir/$linklib"
+		case $host in
+		  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
+		  *-*-sysv4*uw2*) add_dir="-L$dir" ;;
+		  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
+		    *-*-unixware7*) add_dir="-L$dir" ;;
+		  *-*-darwin* )
+		    # if the lib is a module then we can not link against
+		    # it, someone is ignoring the new warnings I added
+		    if /usr/bin/file -L $add 2> /dev/null |
+                      $EGREP ": [^:]* bundle" >/dev/null ; then
+		      $echo "** Warning, lib $linklib is a module, not a shared library"
+		      if test -z "$old_library" ; then
+		        $echo
+		        $echo "** And there doesn't seem to be a static archive available"
+		        $echo "** The link will probably fail, sorry"
+		      else
+		        add="$dir/$old_library"
+		      fi
+		    fi
+		esac
+	      elif test "$hardcode_minus_L" = no; then
+		case $host in
+		*-*-sunos*) add_shlibpath="$dir" ;;
+		esac
+		add_dir="-L$dir"
+		add="-l$name"
+	      elif test "$hardcode_shlibpath_var" = no; then
+		add_shlibpath="$dir"
+		add="-l$name"
+	      else
+		lib_linked=no
+	      fi
+	      ;;
+	    relink)
+	      if test "$hardcode_direct" = yes; then
+		add="$dir/$linklib"
+	      elif test "$hardcode_minus_L" = yes; then
+		add_dir="-L$dir"
+		# Try looking first in the location we're being installed to.
+		if test -n "$inst_prefix_dir"; then
+		  case $libdir in
+		    [\\/]*)
+		      add_dir="$add_dir -L$inst_prefix_dir$libdir"
+		      ;;
+		  esac
+		fi
+		add="-l$name"
+	      elif test "$hardcode_shlibpath_var" = yes; then
+		add_shlibpath="$dir"
+		add="-l$name"
+	      else
+		lib_linked=no
+	      fi
+	      ;;
+	    *) lib_linked=no ;;
+	    esac
+
+	    if test "$lib_linked" != yes; then
+	      $echo "$modename: configuration error: unsupported hardcode properties"
+	      exit $EXIT_FAILURE
+	    fi
+
+	    if test -n "$add_shlibpath"; then
+	      case :$compile_shlibpath: in
+	      *":$add_shlibpath:"*) ;;
+	      *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
+	      esac
+	    fi
+	    if test "$linkmode" = prog; then
+	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
+	      test -n "$add" && compile_deplibs="$add $compile_deplibs"
+	    else
+	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
+	      test -n "$add" && deplibs="$add $deplibs"
+	      if test "$hardcode_direct" != yes && \
+		 test "$hardcode_minus_L" != yes && \
+		 test "$hardcode_shlibpath_var" = yes; then
+		case :$finalize_shlibpath: in
+		*":$libdir:"*) ;;
+		*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
+		esac
+	      fi
+	    fi
+	  fi
+
+	  if test "$linkmode" = prog || test "$mode" = relink; then
+	    add_shlibpath=
+	    add_dir=
+	    add=
+	    # Finalize command for both is simple: just hardcode it.
+	    if test "$hardcode_direct" = yes; then
+	      add="$libdir/$linklib"
+	    elif test "$hardcode_minus_L" = yes; then
+	      add_dir="-L$libdir"
+	      add="-l$name"
+	    elif test "$hardcode_shlibpath_var" = yes; then
+	      case :$finalize_shlibpath: in
+	      *":$libdir:"*) ;;
+	      *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
+	      esac
+	      add="-l$name"
+	    elif test "$hardcode_automatic" = yes; then
+	      if test -n "$inst_prefix_dir" &&
+		 test -f "$inst_prefix_dir$libdir/$linklib" ; then
+	        add="$inst_prefix_dir$libdir/$linklib"
+	      else
+	        add="$libdir/$linklib"
+	      fi
+	    else
+	      # We cannot seem to hardcode it, guess we'll fake it.
+	      add_dir="-L$libdir"
+	      # Try looking first in the location we're being installed to.
+	      if test -n "$inst_prefix_dir"; then
+		case $libdir in
+		  [\\/]*)
+		    add_dir="$add_dir -L$inst_prefix_dir$libdir"
+		    ;;
+		esac
+	      fi
+	      add="-l$name"
+	    fi
+
+	    if test "$linkmode" = prog; then
+	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
+	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
+	    else
+	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
+	      test -n "$add" && deplibs="$add $deplibs"
+	    fi
+	  fi
+	elif test "$linkmode" = prog; then
+	  # Here we assume that one of hardcode_direct or hardcode_minus_L
+	  # is not unsupported.  This is valid on all known static and
+	  # shared platforms.
+	  if test "$hardcode_direct" != unsupported; then
+	    test -n "$old_library" && linklib="$old_library"
+	    compile_deplibs="$dir/$linklib $compile_deplibs"
+	    finalize_deplibs="$dir/$linklib $finalize_deplibs"
+	  else
+	    compile_deplibs="-l$name -L$dir $compile_deplibs"
+	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"
+	  fi
+	elif test "$build_libtool_libs" = yes; then
+	  # Not a shared library
+	  if test "$deplibs_check_method" != pass_all; then
+	    # We're trying link a shared library against a static one
+	    # but the system doesn't support it.
+
+	    # Just print a warning and add the library to dependency_libs so
+	    # that the program can be linked against the static library.
+	    $echo
+	    $echo "*** Warning: This system can not link to static lib archive $lib."
+	    $echo "*** I have the capability to make that library automatically link in when"
+	    $echo "*** you link to this library.  But I can only do this if you have a"
+	    $echo "*** shared version of the library, which you do not appear to have."
+	    if test "$module" = yes; then
+	      $echo "*** But as you try to build a module library, libtool will still create "
+	      $echo "*** a static module, that should work as long as the dlopening application"
+	      $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
+	      if test -z "$global_symbol_pipe"; then
+		$echo
+		$echo "*** However, this would only work if libtool was able to extract symbol"
+		$echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
+		$echo "*** not find such a program.  So, this module is probably useless."
+		$echo "*** \`nm' from GNU binutils and a full rebuild may help."
+	      fi
+	      if test "$build_old_libs" = no; then
+		build_libtool_libs=module
+		build_old_libs=yes
+	      else
+		build_libtool_libs=no
+	      fi
+	    fi
+	  else
+	    deplibs="$dir/$old_library $deplibs"
+	    link_static=yes
+	  fi
+	fi # link shared/static library?
+
+	if test "$linkmode" = lib; then
+	  if test -n "$dependency_libs" &&
+	     { test "$hardcode_into_libs" != yes ||
+	       test "$build_old_libs" = yes ||
+	       test "$link_static" = yes; }; then
+	    # Extract -R from dependency_libs
+	    temp_deplibs=
+	    for libdir in $dependency_libs; do
+	      case $libdir in
+	      -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
+		   case " $xrpath " in
+		   *" $temp_xrpath "*) ;;
+		   *) xrpath="$xrpath $temp_xrpath";;
+		   esac;;
+	      *) temp_deplibs="$temp_deplibs $libdir";;
+	      esac
+	    done
+	    dependency_libs="$temp_deplibs"
+	  fi
+
+	  newlib_search_path="$newlib_search_path $absdir"
+	  # Link against this library
+	  test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
+	  # ... and its dependency_libs
+	  tmp_libs=
+	  for deplib in $dependency_libs; do
+	    newdependency_libs="$deplib $newdependency_libs"
+	    if test "X$duplicate_deps" = "Xyes" ; then
+	      case "$tmp_libs " in
+	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
+	      esac
+	    fi
+	    tmp_libs="$tmp_libs $deplib"
+	  done
+
+	  if test "$link_all_deplibs" != no; then
+	    # Add the search paths of all dependency libraries
+	    for deplib in $dependency_libs; do
+	      case $deplib in
+	      -L*) path="$deplib" ;;
+	      *.la)
+		dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
+		test "X$dir" = "X$deplib" && dir="."
+		# We need an absolute path.
+		case $dir in
+		[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
+		*)
+		  absdir=`cd "$dir" && pwd`
+		  if test -z "$absdir"; then
+		    $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
+		    absdir="$dir"
+		  fi
+		  ;;
+		esac
+		if grep "^installed=no" $deplib > /dev/null; then
+		  path="$absdir/$objdir"
+		else
+		  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
+		  if test -z "$libdir"; then
+		    $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
+		    exit $EXIT_FAILURE
+		  fi
+		  if test "$absdir" != "$libdir"; then
+		    $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
+		  fi
+		  path="$absdir"
+		fi
+		depdepl=
+		case $host in
+		*-*-darwin*)
+		  # we do not want to link against static libs,
+		  # but need to link against shared
+		  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
+		  if test -n "$deplibrary_names" ; then
+		    for tmp in $deplibrary_names ; do
+		      depdepl=$tmp
+		    done
+		    if test -f "$path/$depdepl" ; then
+		      depdepl="$path/$depdepl"
+		    fi
+		    # do not add paths which are already there
+		    case " $newlib_search_path " in
+		    *" $path "*) ;;
+		    *) newlib_search_path="$newlib_search_path $path";;
+		    esac
+		  fi
+		  path=""
+		  ;;
+		*)
+		  path="-L$path"
+		  ;;
+		esac
+		;;
+	      -l*)
+		case $host in
+		*-*-darwin*)
+		  # Again, we only want to link against shared libraries
+		  eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
+		  for tmp in $newlib_search_path ; do
+		    if test -f "$tmp/lib$tmp_libs.dylib" ; then
+		      eval depdepl="$tmp/lib$tmp_libs.dylib"
+		      break
+		    fi
+		  done
+		  path=""
+		  ;;
+		*) continue ;;
+		esac
+		;;
+	      *) continue ;;
+	      esac
+	      case " $deplibs " in
+	      *" $path "*) ;;
+	      *) deplibs="$path $deplibs" ;;
+	      esac
+	      case " $deplibs " in
+	      *" $depdepl "*) ;;
+	      *) deplibs="$depdepl $deplibs" ;;
+	      esac
+	    done
+	  fi # link_all_deplibs != no
+	fi # linkmode = lib
+      done # for deplib in $libs
+      dependency_libs="$newdependency_libs"
+      if test "$pass" = dlpreopen; then
+	# Link the dlpreopened libraries before other libraries
+	for deplib in $save_deplibs; do
+	  deplibs="$deplib $deplibs"
+	done
+      fi
+      if test "$pass" != dlopen; then
+	if test "$pass" != conv; then
+	  # Make sure lib_search_path contains only unique directories.
+	  lib_search_path=
+	  for dir in $newlib_search_path; do
+	    case "$lib_search_path " in
+	    *" $dir "*) ;;
+	    *) lib_search_path="$lib_search_path $dir" ;;
+	    esac
+	  done
+	  newlib_search_path=
+	fi
+
+	if test "$linkmode,$pass" != "prog,link"; then
+	  vars="deplibs"
+	else
+	  vars="compile_deplibs finalize_deplibs"
+	fi
+	for var in $vars dependency_libs; do
+	  # Add libraries to $var in reverse order
+	  eval tmp_libs=\"\$$var\"
+	  new_libs=
+	  for deplib in $tmp_libs; do
+	    # FIXME: Pedantically, this is the right thing to do, so
+	    #        that some nasty dependency loop isn't accidentally
+	    #        broken:
+	    #new_libs="$deplib $new_libs"
+	    # Pragmatically, this seems to cause very few problems in
+	    # practice:
+	    case $deplib in
+	    -L*) new_libs="$deplib $new_libs" ;;
+	    -R*) ;;
+	    *)
+	      # And here is the reason: when a library appears more
+	      # than once as an explicit dependence of a library, or
+	      # is implicitly linked in more than once by the
+	      # compiler, it is considered special, and multiple
+	      # occurrences thereof are not removed.  Compare this
+	      # with having the same library being listed as a
+	      # dependency of multiple other libraries: in this case,
+	      # we know (pedantically, we assume) the library does not
+	      # need to be listed more than once, so we keep only the
+	      # last copy.  This is not always right, but it is rare
+	      # enough that we require users that really mean to play
+	      # such unportable linking tricks to link the library
+	      # using -Wl,-lname, so that libtool does not consider it
+	      # for duplicate removal.
+	      case " $specialdeplibs " in
+	      *" $deplib "*) new_libs="$deplib $new_libs" ;;
+	      *)
+		case " $new_libs " in
+		*" $deplib "*) ;;
+		*) new_libs="$deplib $new_libs" ;;
+		esac
+		;;
+	      esac
+	      ;;
+	    esac
+	  done
+	  tmp_libs=
+	  for deplib in $new_libs; do
+	    case $deplib in
+	    -L*)
+	      case " $tmp_libs " in
+	      *" $deplib "*) ;;
+	      *) tmp_libs="$tmp_libs $deplib" ;;
+	      esac
+	      ;;
+	    *) tmp_libs="$tmp_libs $deplib" ;;
+	    esac
+	  done
+	  eval $var=\"$tmp_libs\"
+	done # for var
+      fi
+      # Last step: remove runtime libs from dependency_libs
+      # (they stay in deplibs)
+      tmp_libs=
+      for i in $dependency_libs ; do
+	case " $predeps $postdeps $compiler_lib_search_path " in
+	*" $i "*)
+	  i=""
+	  ;;
+	esac
+	if test -n "$i" ; then
+	  tmp_libs="$tmp_libs $i"
+	fi
+      done
+      dependency_libs=$tmp_libs
+    done # for pass
+    if test "$linkmode" = prog; then
+      dlfiles="$newdlfiles"
+      dlprefiles="$newdlprefiles"
+    fi
+
+    case $linkmode in
+    oldlib)
+      if test -n "$deplibs"; then
+	$echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
+      fi
+
+      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+	$echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$rpath"; then
+	$echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$xrpath"; then
+	$echo "$modename: warning: \`-R' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$vinfo"; then
+	$echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$release"; then
+	$echo "$modename: warning: \`-release' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
+	$echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
+      fi
+
+      # Now set the variables for building old libraries.
+      build_libtool_libs=no
+      oldlibs="$output"
+      objs="$objs$old_deplibs"
+      ;;
+
+    lib)
+      # Make sure we only generate libraries of the form `libNAME.la'.
+      case $outputname in
+      lib*)
+	name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
+	eval shared_ext=\"$shrext_cmds\"
+	eval libname=\"$libname_spec\"
+	;;
+      *)
+	if test "$module" = no; then
+	  $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+	if test "$need_lib_prefix" != no; then
+	  # Add the "lib" prefix for modules if required
+	  name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
+	  eval shared_ext=\"$shrext_cmds\"
+	  eval libname=\"$libname_spec\"
+	else
+	  libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
+	fi
+	;;
+      esac
+
+      if test -n "$objs"; then
+	if test "$deplibs_check_method" != pass_all; then
+	  $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
+	  exit $EXIT_FAILURE
+	else
+	  $echo
+	  $echo "*** Warning: Linking the shared library $output against the non-libtool"
+	  $echo "*** objects $objs is not portable!"
+	  libobjs="$libobjs $objs"
+	fi
+      fi
+
+      if test "$dlself" != no; then
+	$echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
+      fi
+
+      set dummy $rpath
+      if test "$#" -gt 2; then
+	$echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
+      fi
+      install_libdir="$2"
+
+      oldlibs=
+      if test -z "$rpath"; then
+	if test "$build_libtool_libs" = yes; then
+	  # Building a libtool convenience library.
+	  # Some compilers have problems with a `.al' extension so
+	  # convenience libraries should have the same extension an
+	  # archive normally would.
+	  oldlibs="$output_objdir/$libname.$libext $oldlibs"
+	  build_libtool_libs=convenience
+	  build_old_libs=yes
+	fi
+
+	if test -n "$vinfo"; then
+	  $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
+	fi
+
+	if test -n "$release"; then
+	  $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
+	fi
+      else
+
+	# Parse the version information argument.
+	save_ifs="$IFS"; IFS=':'
+	set dummy $vinfo 0 0 0
+	IFS="$save_ifs"
+
+	if test -n "$8"; then
+	  $echo "$modename: too many parameters to \`-version-info'" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	# convert absolute version numbers to libtool ages
+	# this retains compatibility with .la files and attempts
+	# to make the code below a bit more comprehensible
+
+	case $vinfo_number in
+	yes)
+	  number_major="$2"
+	  number_minor="$3"
+	  number_revision="$4"
+	  #
+	  # There are really only two kinds -- those that
+	  # use the current revision as the major version
+	  # and those that subtract age and use age as
+	  # a minor version.  But, then there is irix
+	  # which has an extra 1 added just for fun
+	  #
+	  case $version_type in
+	  darwin|linux|osf|windows)
+	    current=`expr $number_major + $number_minor`
+	    age="$number_minor"
+	    revision="$number_revision"
+	    ;;
+	  freebsd-aout|freebsd-elf|sunos)
+	    current="$number_major"
+	    revision="$number_minor"
+	    age="0"
+	    ;;
+	  irix|nonstopux)
+	    current=`expr $number_major + $number_minor - 1`
+	    age="$number_minor"
+	    revision="$number_minor"
+	    ;;
+	  *)
+	    $echo "$modename: unknown library version type \`$version_type'" 1>&2
+	    $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
+	    exit $EXIT_FAILURE
+	    ;;
+	  esac
+	  ;;
+	no)
+	  current="$2"
+	  revision="$3"
+	  age="$4"
+	  ;;
+	esac
+
+	# Check that each of the things are valid numbers.
+	case $current in
+	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+	*)
+	  $echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2
+	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+
+	case $revision in
+	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+	*)
+	  $echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2
+	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+
+	case $age in
+	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+	*)
+	  $echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2
+	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+
+	if test "$age" -gt "$current"; then
+	  $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
+	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	# Calculate the version variables.
+	major=
+	versuffix=
+	verstring=
+	case $version_type in
+	none) ;;
+
+	darwin)
+	  # Like Linux, but with the current version available in
+	  # verstring for coding it into the library header
+	  major=.`expr $current - $age`
+	  versuffix="$major.$age.$revision"
+	  # Darwin ld doesn't like 0 for these options...
+	  minor_current=`expr $current + 1`
+	  verstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
+	  ;;
+
+	freebsd-aout)
+	  major=".$current"
+	  versuffix=".$current.$revision";
+	  ;;
+
+	freebsd-elf)
+	  major=".$current"
+	  versuffix=".$current";
+	  ;;
+
+	irix | nonstopux)
+	  major=`expr $current - $age + 1`
+
+	  case $version_type in
+	    nonstopux) verstring_prefix=nonstopux ;;
+	    *)         verstring_prefix=sgi ;;
+	  esac
+	  verstring="$verstring_prefix$major.$revision"
+
+	  # Add in all the interfaces that we are compatible with.
+	  loop=$revision
+	  while test "$loop" -ne 0; do
+	    iface=`expr $revision - $loop`
+	    loop=`expr $loop - 1`
+	    verstring="$verstring_prefix$major.$iface:$verstring"
+	  done
+
+	  # Before this point, $major must not contain `.'.
+	  major=.$major
+	  versuffix="$major.$revision"
+	  ;;
+
+	linux)
+	  major=.`expr $current - $age`
+	  versuffix="$major.$age.$revision"
+	  ;;
+
+	osf)
+	  major=.`expr $current - $age`
+	  versuffix=".$current.$age.$revision"
+	  verstring="$current.$age.$revision"
+
+	  # Add in all the interfaces that we are compatible with.
+	  loop=$age
+	  while test "$loop" -ne 0; do
+	    iface=`expr $current - $loop`
+	    loop=`expr $loop - 1`
+	    verstring="$verstring:${iface}.0"
+	  done
+
+	  # Make executables depend on our current version.
+	  verstring="$verstring:${current}.0"
+	  ;;
+
+	sunos)
+	  major=".$current"
+	  versuffix=".$current.$revision"
+	  ;;
+
+	windows)
+	  # Use '-' rather than '.', since we only want one
+	  # extension on DOS 8.3 filesystems.
+	  major=`expr $current - $age`
+	  versuffix="-$major"
+	  ;;
+
+	*)
+	  $echo "$modename: unknown library version type \`$version_type'" 1>&2
+	  $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+
+	# Clear the version info if we defaulted, and they specified a release.
+	if test -z "$vinfo" && test -n "$release"; then
+	  major=
+	  case $version_type in
+	  darwin)
+	    # we can't check for "0.0" in archive_cmds due to quoting
+	    # problems, so we reset it completely
+	    verstring=
+	    ;;
+	  *)
+	    verstring="0.0"
+	    ;;
+	  esac
+	  if test "$need_version" = no; then
+	    versuffix=
+	  else
+	    versuffix=".0.0"
+	  fi
+	fi
+
+	# Remove version info from name if versioning should be avoided
+	if test "$avoid_version" = yes && test "$need_version" = no; then
+	  major=
+	  versuffix=
+	  verstring=""
+	fi
+
+	# Check to see if the archive will have undefined symbols.
+	if test "$allow_undefined" = yes; then
+	  if test "$allow_undefined_flag" = unsupported; then
+	    $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
+	    build_libtool_libs=no
+	    build_old_libs=yes
+	  fi
+	else
+	  # Don't allow undefined symbols.
+	  allow_undefined_flag="$no_undefined_flag"
+	fi
+      fi
+
+      if test "$mode" != relink; then
+	# Remove our outputs, but don't remove object files since they
+	# may have been created when compiling PIC objects.
+	removelist=
+	tempremovelist=`$echo "$output_objdir/*"`
+	for p in $tempremovelist; do
+	  case $p in
+	    *.$objext)
+	       ;;
+	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
+	       if test "X$precious_files_regex" != "X"; then
+	         if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
+	         then
+		   continue
+		 fi
+	       fi
+	       removelist="$removelist $p"
+	       ;;
+	    *) ;;
+	  esac
+	done
+	if test -n "$removelist"; then
+	  $show "${rm}r $removelist"
+	  $run ${rm}r $removelist
+	fi
+      fi
+
+      # Now set the variables for building old libraries.
+      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
+	oldlibs="$oldlibs $output_objdir/$libname.$libext"
+
+	# Transform .lo files to .o files.
+	oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
+      fi
+
+      # Eliminate all temporary directories.
+      for path in $notinst_path; do
+	lib_search_path=`$echo "$lib_search_path " | ${SED} -e "s% $path % %g"`
+	deplibs=`$echo "$deplibs " | ${SED} -e "s% -L$path % %g"`
+	dependency_libs=`$echo "$dependency_libs " | ${SED} -e "s% -L$path % %g"`
+      done
+
+      if test -n "$xrpath"; then
+	# If the user specified any rpath flags, then add them.
+	temp_xrpath=
+	for libdir in $xrpath; do
+	  temp_xrpath="$temp_xrpath -R$libdir"
+	  case "$finalize_rpath " in
+	  *" $libdir "*) ;;
+	  *) finalize_rpath="$finalize_rpath $libdir" ;;
+	  esac
+	done
+	if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
+	  dependency_libs="$temp_xrpath $dependency_libs"
+	fi
+      fi
+
+      # Make sure dlfiles contains only unique files that won't be dlpreopened
+      old_dlfiles="$dlfiles"
+      dlfiles=
+      for lib in $old_dlfiles; do
+	case " $dlprefiles $dlfiles " in
+	*" $lib "*) ;;
+	*) dlfiles="$dlfiles $lib" ;;
+	esac
+      done
+
+      # Make sure dlprefiles contains only unique files
+      old_dlprefiles="$dlprefiles"
+      dlprefiles=
+      for lib in $old_dlprefiles; do
+	case "$dlprefiles " in
+	*" $lib "*) ;;
+	*) dlprefiles="$dlprefiles $lib" ;;
+	esac
+      done
+
+      if test "$build_libtool_libs" = yes; then
+	if test -n "$rpath"; then
+	  case $host in
+	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
+	    # these systems don't actually have a c library (as such)!
+	    ;;
+	  *-*-rhapsody* | *-*-darwin1.[012])
+	    # Rhapsody C library is in the System framework
+	    deplibs="$deplibs -framework System"
+	    ;;
+	  *-*-netbsd*)
+	    # Don't link with libc until the a.out ld.so is fixed.
+	    ;;
+	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+	    # Do not include libc due to us having libc/libc_r.
+	    ;;
+	  *-*-sco3.2v5* | *-*-sco5v6*)
+	    # Causes problems with __ctype
+	    ;;
+	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
+	    # Compiler inserts libc in the correct place for threads to work
+	    ;;
+ 	  *)
+	    # Add libc to deplibs on all other systems if necessary.
+	    if test "$build_libtool_need_lc" = "yes"; then
+	      deplibs="$deplibs -lc"
+	    fi
+	    ;;
+	  esac
+	fi
+
+	# Transform deplibs into only deplibs that can be linked in shared.
+	name_save=$name
+	libname_save=$libname
+	release_save=$release
+	versuffix_save=$versuffix
+	major_save=$major
+	# I'm not sure if I'm treating the release correctly.  I think
+	# release should show up in the -l (ie -lgmp5) so we don't want to
+	# add it in twice.  Is that correct?
+	release=""
+	versuffix=""
+	major=""
+	newdeplibs=
+	droppeddeps=no
+	case $deplibs_check_method in
+	pass_all)
+	  # Don't check for shared/static.  Everything works.
+	  # This might be a little naive.  We might want to check
+	  # whether the library exists or not.  But this is on
+	  # osf3 & osf4 and I'm not really sure... Just
+	  # implementing what was already the behavior.
+	  newdeplibs=$deplibs
+	  ;;
+	test_compile)
+	  # This code stresses the "libraries are programs" paradigm to its
+	  # limits. Maybe even breaks it.  We compile a program, linking it
+	  # against the deplibs as a proxy for the library.  Then we can check
+	  # whether they linked in statically or dynamically with ldd.
+	  $rm conftest.c
+	  cat > conftest.c <<EOF
+	  int main() { return 0; }
+EOF
+	  $rm conftest
+	  $LTCC $LTCFLAGS -o conftest conftest.c $deplibs
+	  if test "$?" -eq 0 ; then
+	    ldd_output=`ldd conftest`
+	    for i in $deplibs; do
+	      name=`expr $i : '-l\(.*\)'`
+	      # If $name is empty we are operating on a -L argument.
+              if test "$name" != "" && test "$name" -ne "0"; then
+		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+		  case " $predeps $postdeps " in
+		  *" $i "*)
+		    newdeplibs="$newdeplibs $i"
+		    i=""
+		    ;;
+		  esac
+	        fi
+		if test -n "$i" ; then
+		  libname=`eval \\$echo \"$libname_spec\"`
+		  deplib_matches=`eval \\$echo \"$library_names_spec\"`
+		  set dummy $deplib_matches
+		  deplib_match=$2
+		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
+		    newdeplibs="$newdeplibs $i"
+		  else
+		    droppeddeps=yes
+		    $echo
+		    $echo "*** Warning: dynamic linker does not accept needed library $i."
+		    $echo "*** I have the capability to make that library automatically link in when"
+		    $echo "*** you link to this library.  But I can only do this if you have a"
+		    $echo "*** shared version of the library, which I believe you do not have"
+		    $echo "*** because a test_compile did reveal that the linker did not use it for"
+		    $echo "*** its dynamic dependency list that programs get resolved with at runtime."
+		  fi
+		fi
+	      else
+		newdeplibs="$newdeplibs $i"
+	      fi
+	    done
+	  else
+	    # Error occurred in the first compile.  Let's try to salvage
+	    # the situation: Compile a separate program for each library.
+	    for i in $deplibs; do
+	      name=`expr $i : '-l\(.*\)'`
+	      # If $name is empty we are operating on a -L argument.
+              if test "$name" != "" && test "$name" != "0"; then
+		$rm conftest
+		$LTCC $LTCFLAGS -o conftest conftest.c $i
+		# Did it work?
+		if test "$?" -eq 0 ; then
+		  ldd_output=`ldd conftest`
+		  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+		    case " $predeps $postdeps " in
+		    *" $i "*)
+		      newdeplibs="$newdeplibs $i"
+		      i=""
+		      ;;
+		    esac
+		  fi
+		  if test -n "$i" ; then
+		    libname=`eval \\$echo \"$libname_spec\"`
+		    deplib_matches=`eval \\$echo \"$library_names_spec\"`
+		    set dummy $deplib_matches
+		    deplib_match=$2
+		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
+		      newdeplibs="$newdeplibs $i"
+		    else
+		      droppeddeps=yes
+		      $echo
+		      $echo "*** Warning: dynamic linker does not accept needed library $i."
+		      $echo "*** I have the capability to make that library automatically link in when"
+		      $echo "*** you link to this library.  But I can only do this if you have a"
+		      $echo "*** shared version of the library, which you do not appear to have"
+		      $echo "*** because a test_compile did reveal that the linker did not use this one"
+		      $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
+		    fi
+		  fi
+		else
+		  droppeddeps=yes
+		  $echo
+		  $echo "*** Warning!  Library $i is needed by this library but I was not able to"
+		  $echo "***  make it link in!  You will probably need to install it or some"
+		  $echo "*** library that it depends on before this library will be fully"
+		  $echo "*** functional.  Installing it before continuing would be even better."
+		fi
+	      else
+		newdeplibs="$newdeplibs $i"
+	      fi
+	    done
+	  fi
+	  ;;
+	file_magic*)
+	  set dummy $deplibs_check_method
+	  file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
+	  for a_deplib in $deplibs; do
+	    name=`expr $a_deplib : '-l\(.*\)'`
+	    # If $name is empty we are operating on a -L argument.
+            if test "$name" != "" && test  "$name" != "0"; then
+	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+		case " $predeps $postdeps " in
+		*" $a_deplib "*)
+		  newdeplibs="$newdeplibs $a_deplib"
+		  a_deplib=""
+		  ;;
+		esac
+	      fi
+	      if test -n "$a_deplib" ; then
+		libname=`eval \\$echo \"$libname_spec\"`
+		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
+		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
+		  for potent_lib in $potential_libs; do
+		      # Follow soft links.
+		      if ls -lLd "$potent_lib" 2>/dev/null \
+			 | grep " -> " >/dev/null; then
+			continue
+		      fi
+		      # The statement above tries to avoid entering an
+		      # endless loop below, in case of cyclic links.
+		      # We might still enter an endless loop, since a link
+		      # loop can be closed while we follow links,
+		      # but so what?
+		      potlib="$potent_lib"
+		      while test -h "$potlib" 2>/dev/null; do
+			potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
+			case $potliblink in
+			[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
+			*) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
+			esac
+		      done
+		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
+			 | ${SED} 10q \
+			 | $EGREP "$file_magic_regex" > /dev/null; then
+			newdeplibs="$newdeplibs $a_deplib"
+			a_deplib=""
+			break 2
+		      fi
+		  done
+		done
+	      fi
+	      if test -n "$a_deplib" ; then
+		droppeddeps=yes
+		$echo
+		$echo "*** Warning: linker path does not have real file for library $a_deplib."
+		$echo "*** I have the capability to make that library automatically link in when"
+		$echo "*** you link to this library.  But I can only do this if you have a"
+		$echo "*** shared version of the library, which you do not appear to have"
+		$echo "*** because I did check the linker path looking for a file starting"
+		if test -z "$potlib" ; then
+		  $echo "*** with $libname but no candidates were found. (...for file magic test)"
+		else
+		  $echo "*** with $libname and none of the candidates passed a file format test"
+		  $echo "*** using a file magic. Last file checked: $potlib"
+		fi
+	      fi
+	    else
+	      # Add a -L argument.
+	      newdeplibs="$newdeplibs $a_deplib"
+	    fi
+	  done # Gone through all deplibs.
+	  ;;
+	match_pattern*)
+	  set dummy $deplibs_check_method
+	  match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
+	  for a_deplib in $deplibs; do
+	    name=`expr $a_deplib : '-l\(.*\)'`
+	    # If $name is empty we are operating on a -L argument.
+	    if test -n "$name" && test "$name" != "0"; then
+	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+		case " $predeps $postdeps " in
+		*" $a_deplib "*)
+		  newdeplibs="$newdeplibs $a_deplib"
+		  a_deplib=""
+		  ;;
+		esac
+	      fi
+	      if test -n "$a_deplib" ; then
+		libname=`eval \\$echo \"$libname_spec\"`
+		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
+		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
+		  for potent_lib in $potential_libs; do
+		    potlib="$potent_lib" # see symlink-check above in file_magic test
+		    if eval $echo \"$potent_lib\" 2>/dev/null \
+		        | ${SED} 10q \
+		        | $EGREP "$match_pattern_regex" > /dev/null; then
+		      newdeplibs="$newdeplibs $a_deplib"
+		      a_deplib=""
+		      break 2
+		    fi
+		  done
+		done
+	      fi
+	      if test -n "$a_deplib" ; then
+		droppeddeps=yes
+		$echo
+		$echo "*** Warning: linker path does not have real file for library $a_deplib."
+		$echo "*** I have the capability to make that library automatically link in when"
+		$echo "*** you link to this library.  But I can only do this if you have a"
+		$echo "*** shared version of the library, which you do not appear to have"
+		$echo "*** because I did check the linker path looking for a file starting"
+		if test -z "$potlib" ; then
+		  $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
+		else
+		  $echo "*** with $libname and none of the candidates passed a file format test"
+		  $echo "*** using a regex pattern. Last file checked: $potlib"
+		fi
+	      fi
+	    else
+	      # Add a -L argument.
+	      newdeplibs="$newdeplibs $a_deplib"
+	    fi
+	  done # Gone through all deplibs.
+	  ;;
+	none | unknown | *)
+	  newdeplibs=""
+	  tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
+	    -e 's/ -[LR][^ ]*//g'`
+	  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+	    for i in $predeps $postdeps ; do
+	      # can't use Xsed below, because $i might contain '/'
+	      tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
+	    done
+	  fi
+	  if $echo "X $tmp_deplibs" | $Xsed -e 's/[ 	]//g' \
+	    | grep . >/dev/null; then
+	    $echo
+	    if test "X$deplibs_check_method" = "Xnone"; then
+	      $echo "*** Warning: inter-library dependencies are not supported in this platform."
+	    else
+	      $echo "*** Warning: inter-library dependencies are not known to be supported."
+	    fi
+	    $echo "*** All declared inter-library dependencies are being dropped."
+	    droppeddeps=yes
+	  fi
+	  ;;
+	esac
+	versuffix=$versuffix_save
+	major=$major_save
+	release=$release_save
+	libname=$libname_save
+	name=$name_save
+
+	case $host in
+	*-*-rhapsody* | *-*-darwin1.[012])
+	  # On Rhapsody replace the C library is the System framework
+	  newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
+	  ;;
+	esac
+
+	if test "$droppeddeps" = yes; then
+	  if test "$module" = yes; then
+	    $echo
+	    $echo "*** Warning: libtool could not satisfy all declared inter-library"
+	    $echo "*** dependencies of module $libname.  Therefore, libtool will create"
+	    $echo "*** a static module, that should work as long as the dlopening"
+	    $echo "*** application is linked with the -dlopen flag."
+	    if test -z "$global_symbol_pipe"; then
+	      $echo
+	      $echo "*** However, this would only work if libtool was able to extract symbol"
+	      $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
+	      $echo "*** not find such a program.  So, this module is probably useless."
+	      $echo "*** \`nm' from GNU binutils and a full rebuild may help."
+	    fi
+	    if test "$build_old_libs" = no; then
+	      oldlibs="$output_objdir/$libname.$libext"
+	      build_libtool_libs=module
+	      build_old_libs=yes
+	    else
+	      build_libtool_libs=no
+	    fi
+	  else
+	    $echo "*** The inter-library dependencies that have been dropped here will be"
+	    $echo "*** automatically added whenever a program is linked with this library"
+	    $echo "*** or is declared to -dlopen it."
+
+	    if test "$allow_undefined" = no; then
+	      $echo
+	      $echo "*** Since this library must not contain undefined symbols,"
+	      $echo "*** because either the platform does not support them or"
+	      $echo "*** it was explicitly requested with -no-undefined,"
+	      $echo "*** libtool will only create a static version of it."
+	      if test "$build_old_libs" = no; then
+		oldlibs="$output_objdir/$libname.$libext"
+		build_libtool_libs=module
+		build_old_libs=yes
+	      else
+		build_libtool_libs=no
+	      fi
+	    fi
+	  fi
+	fi
+	# Done checking deplibs!
+	deplibs=$newdeplibs
+      fi
+
+
+      # move library search paths that coincide with paths to not yet
+      # installed libraries to the beginning of the library search list
+      new_libs=
+      for path in $notinst_path; do
+	case " $new_libs " in
+	*" -L$path/$objdir "*) ;;
+	*)
+	  case " $deplibs " in
+	  *" -L$path/$objdir "*)
+	    new_libs="$new_libs -L$path/$objdir" ;;
+	  esac
+	  ;;
+	esac
+      done
+      for deplib in $deplibs; do
+	case $deplib in
+	-L*)
+	  case " $new_libs " in
+	  *" $deplib "*) ;;
+	  *) new_libs="$new_libs $deplib" ;;
+	  esac
+	  ;;
+	*) new_libs="$new_libs $deplib" ;;
+	esac
+      done
+      deplibs="$new_libs"
+
+
+      # All the library-specific variables (install_libdir is set above).
+      library_names=
+      old_library=
+      dlname=
+
+      # Test again, we may have decided not to build it any more
+      if test "$build_libtool_libs" = yes; then
+	if test "$hardcode_into_libs" = yes; then
+	  # Hardcode the library paths
+	  hardcode_libdirs=
+	  dep_rpath=
+	  rpath="$finalize_rpath"
+	  test "$mode" != relink && rpath="$compile_rpath$rpath"
+	  for libdir in $rpath; do
+	    if test -n "$hardcode_libdir_flag_spec"; then
+	      if test -n "$hardcode_libdir_separator"; then
+		if test -z "$hardcode_libdirs"; then
+		  hardcode_libdirs="$libdir"
+		else
+		  # Just accumulate the unique libdirs.
+		  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+		  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		    ;;
+		  *)
+		    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
+		    ;;
+		  esac
+		fi
+	      else
+		eval flag=\"$hardcode_libdir_flag_spec\"
+		dep_rpath="$dep_rpath $flag"
+	      fi
+	    elif test -n "$runpath_var"; then
+	      case "$perm_rpath " in
+	      *" $libdir "*) ;;
+	      *) perm_rpath="$perm_rpath $libdir" ;;
+	      esac
+	    fi
+	  done
+	  # Substitute the hardcoded libdirs into the rpath.
+	  if test -n "$hardcode_libdir_separator" &&
+	     test -n "$hardcode_libdirs"; then
+	    libdir="$hardcode_libdirs"
+	    if test -n "$hardcode_libdir_flag_spec_ld"; then
+	      eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
+	    else
+	      eval dep_rpath=\"$hardcode_libdir_flag_spec\"
+	    fi
+	  fi
+	  if test -n "$runpath_var" && test -n "$perm_rpath"; then
+	    # We should set the runpath_var.
+	    rpath=
+	    for dir in $perm_rpath; do
+	      rpath="$rpath$dir:"
+	    done
+	    eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
+	  fi
+	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
+	fi
+
+	shlibpath="$finalize_shlibpath"
+	test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
+	if test -n "$shlibpath"; then
+	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
+	fi
+
+	# Get the real and link names of the library.
+	eval shared_ext=\"$shrext_cmds\"
+	eval library_names=\"$library_names_spec\"
+	set dummy $library_names
+	realname="$2"
+	shift; shift
+
+	if test -n "$soname_spec"; then
+	  eval soname=\"$soname_spec\"
+	else
+	  soname="$realname"
+	fi
+	if test -z "$dlname"; then
+	  dlname=$soname
+	fi
+
+	lib="$output_objdir/$realname"
+	linknames=
+	for link
+	do
+	  linknames="$linknames $link"
+	done
+
+	# Use standard objects if they are pic
+	test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+
+	# Prepare the list of exported symbols
+	if test -z "$export_symbols"; then
+	  if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
+	    $show "generating symbol list for \`$libname.la'"
+	    export_symbols="$output_objdir/$libname.exp"
+	    $run $rm $export_symbols
+	    cmds=$export_symbols_cmds
+	    save_ifs="$IFS"; IFS='~'
+	    for cmd in $cmds; do
+	      IFS="$save_ifs"
+	      eval cmd=\"$cmd\"
+	      if len=`expr "X$cmd" : ".*"` &&
+	       test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+	        $show "$cmd"
+	        $run eval "$cmd" || exit $?
+	        skipped_export=false
+	      else
+	        # The command line is too long to execute in one step.
+	        $show "using reloadable object file for export list..."
+	        skipped_export=:
+		# Break out early, otherwise skipped_export may be
+		# set to false by a later but shorter cmd.
+		break
+	      fi
+	    done
+	    IFS="$save_ifs"
+	    if test -n "$export_symbols_regex"; then
+	      $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
+	      $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
+	      $show "$mv \"${export_symbols}T\" \"$export_symbols\""
+	      $run eval '$mv "${export_symbols}T" "$export_symbols"'
+	    fi
+	  fi
+	fi
+
+	if test -n "$export_symbols" && test -n "$include_expsyms"; then
+	  $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
+	fi
+
+	tmp_deplibs=
+	for test_deplib in $deplibs; do
+		case " $convenience " in
+		*" $test_deplib "*) ;;
+		*)
+			tmp_deplibs="$tmp_deplibs $test_deplib"
+			;;
+		esac
+	done
+	deplibs="$tmp_deplibs"
+
+	if test -n "$convenience"; then
+	  if test -n "$whole_archive_flag_spec"; then
+	    save_libobjs=$libobjs
+	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
+	  else
+	    gentop="$output_objdir/${outputname}x"
+	    generated="$generated $gentop"
+
+	    func_extract_archives $gentop $convenience
+	    libobjs="$libobjs $func_extract_archives_result"
+	  fi
+	fi
+	
+	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
+	  eval flag=\"$thread_safe_flag_spec\"
+	  linker_flags="$linker_flags $flag"
+	fi
+
+	# Make a backup of the uninstalled library when relinking
+	if test "$mode" = relink; then
+	  $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
+	fi
+
+	# Do each of the archive commands.
+	if test "$module" = yes && test -n "$module_cmds" ; then
+	  if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
+	    eval test_cmds=\"$module_expsym_cmds\"
+	    cmds=$module_expsym_cmds
+	  else
+	    eval test_cmds=\"$module_cmds\"
+	    cmds=$module_cmds
+	  fi
+	else
+	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
+	  eval test_cmds=\"$archive_expsym_cmds\"
+	  cmds=$archive_expsym_cmds
+	else
+	  eval test_cmds=\"$archive_cmds\"
+	  cmds=$archive_cmds
+	  fi
+	fi
+
+	if test "X$skipped_export" != "X:" &&
+	   len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
+	   test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+	  :
+	else
+	  # The command line is too long to link in one step, link piecewise.
+	  $echo "creating reloadable object files..."
+
+	  # Save the value of $output and $libobjs because we want to
+	  # use them later.  If we have whole_archive_flag_spec, we
+	  # want to use save_libobjs as it was before
+	  # whole_archive_flag_spec was expanded, because we can't
+	  # assume the linker understands whole_archive_flag_spec.
+	  # This may have to be revisited, in case too many
+	  # convenience libraries get linked in and end up exceeding
+	  # the spec.
+	  if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
+	    save_libobjs=$libobjs
+	  fi
+	  save_output=$output
+	  output_la=`$echo "X$output" | $Xsed -e "$basename"`
+
+	  # Clear the reloadable object creation command queue and
+	  # initialize k to one.
+	  test_cmds=
+	  concat_cmds=
+	  objlist=
+	  delfiles=
+	  last_robj=
+	  k=1
+	  output=$output_objdir/$output_la-${k}.$objext
+	  # Loop over the list of objects to be linked.
+	  for obj in $save_libobjs
+	  do
+	    eval test_cmds=\"$reload_cmds $objlist $last_robj\"
+	    if test "X$objlist" = X ||
+	       { len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
+		 test "$len" -le "$max_cmd_len"; }; then
+	      objlist="$objlist $obj"
+	    else
+	      # The command $test_cmds is almost too long, add a
+	      # command to the queue.
+	      if test "$k" -eq 1 ; then
+		# The first file doesn't have a previous command to add.
+		eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
+	      else
+		# All subsequent reloadable object files will link in
+		# the last one created.
+		eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
+	      fi
+	      last_robj=$output_objdir/$output_la-${k}.$objext
+	      k=`expr $k + 1`
+	      output=$output_objdir/$output_la-${k}.$objext
+	      objlist=$obj
+	      len=1
+	    fi
+	  done
+	  # Handle the remaining objects by creating one last
+	  # reloadable object file.  All subsequent reloadable object
+	  # files will link in the last one created.
+	  test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+	  eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
+
+	  if ${skipped_export-false}; then
+	    $show "generating symbol list for \`$libname.la'"
+	    export_symbols="$output_objdir/$libname.exp"
+	    $run $rm $export_symbols
+	    libobjs=$output
+	    # Append the command to create the export file.
+	    eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
+          fi
+
+	  # Set up a command to remove the reloadable object files
+	  # after they are used.
+	  i=0
+	  while test "$i" -lt "$k"
+	  do
+	    i=`expr $i + 1`
+	    delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
+	  done
+
+	  $echo "creating a temporary reloadable object file: $output"
+
+	  # Loop through the commands generated above and execute them.
+	  save_ifs="$IFS"; IFS='~'
+	  for cmd in $concat_cmds; do
+	    IFS="$save_ifs"
+	    $show "$cmd"
+	    $run eval "$cmd" || exit $?
+	  done
+	  IFS="$save_ifs"
+
+	  libobjs=$output
+	  # Restore the value of output.
+	  output=$save_output
+
+	  if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
+	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
+	  fi
+	  # Expand the library linking commands again to reset the
+	  # value of $libobjs for piecewise linking.
+
+	  # Do each of the archive commands.
+	  if test "$module" = yes && test -n "$module_cmds" ; then
+	    if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
+	      cmds=$module_expsym_cmds
+	    else
+	      cmds=$module_cmds
+	    fi
+	  else
+	  if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
+	    cmds=$archive_expsym_cmds
+	  else
+	    cmds=$archive_cmds
+	    fi
+	  fi
+
+	  # Append the command to remove the reloadable object files
+	  # to the just-reset $cmds.
+	  eval cmds=\"\$cmds~\$rm $delfiles\"
+	fi
+	save_ifs="$IFS"; IFS='~'
+	for cmd in $cmds; do
+	  IFS="$save_ifs"
+	  eval cmd=\"$cmd\"
+	  $show "$cmd"
+	  $run eval "$cmd" || {
+	    lt_exit=$?
+
+	    # Restore the uninstalled library and exit
+	    if test "$mode" = relink; then
+	      $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
+	    fi
+
+	    exit $lt_exit
+	  }
+	done
+	IFS="$save_ifs"
+
+	# Restore the uninstalled library and exit
+	if test "$mode" = relink; then
+	  $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
+
+	  if test -n "$convenience"; then
+	    if test -z "$whole_archive_flag_spec"; then
+	      $show "${rm}r $gentop"
+	      $run ${rm}r "$gentop"
+	    fi
+	  fi
+
+	  exit $EXIT_SUCCESS
+	fi
+
+	# Create links to the real library.
+	for linkname in $linknames; do
+	  if test "$realname" != "$linkname"; then
+	    $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
+	    $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
+	  fi
+	done
+
+	# If -module or -export-dynamic was specified, set the dlname.
+	if test "$module" = yes || test "$export_dynamic" = yes; then
+	  # On all known operating systems, these are identical.
+	  dlname="$soname"
+	fi
+      fi
+      ;;
+
+    obj)
+      if test -n "$deplibs"; then
+	$echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
+      fi
+
+      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+	$echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
+      fi
+
+      if test -n "$rpath"; then
+	$echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
+      fi
+
+      if test -n "$xrpath"; then
+	$echo "$modename: warning: \`-R' is ignored for objects" 1>&2
+      fi
+
+      if test -n "$vinfo"; then
+	$echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
+      fi
+
+      if test -n "$release"; then
+	$echo "$modename: warning: \`-release' is ignored for objects" 1>&2
+      fi
+
+      case $output in
+      *.lo)
+	if test -n "$objs$old_deplibs"; then
+	  $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+	libobj="$output"
+	obj=`$echo "X$output" | $Xsed -e "$lo2o"`
+	;;
+      *)
+	libobj=
+	obj="$output"
+	;;
+      esac
+
+      # Delete the old objects.
+      $run $rm $obj $libobj
+
+      # Objects from convenience libraries.  This assumes
+      # single-version convenience libraries.  Whenever we create
+      # different ones for PIC/non-PIC, this we'll have to duplicate
+      # the extraction.
+      reload_conv_objs=
+      gentop=
+      # reload_cmds runs $LD directly, so let us get rid of
+      # -Wl from whole_archive_flag_spec
+      wl=
+
+      if test -n "$convenience"; then
+	if test -n "$whole_archive_flag_spec"; then
+	  eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
+	else
+	  gentop="$output_objdir/${obj}x"
+	  generated="$generated $gentop"
+
+	  func_extract_archives $gentop $convenience
+	  reload_conv_objs="$reload_objs $func_extract_archives_result"
+	fi
+      fi
+
+      # Create the old-style object.
+      reload_objs="$objs$old_deplibs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
+
+      output="$obj"
+      cmds=$reload_cmds
+      save_ifs="$IFS"; IFS='~'
+      for cmd in $cmds; do
+	IFS="$save_ifs"
+	eval cmd=\"$cmd\"
+	$show "$cmd"
+	$run eval "$cmd" || exit $?
+      done
+      IFS="$save_ifs"
+
+      # Exit if we aren't doing a library object file.
+      if test -z "$libobj"; then
+	if test -n "$gentop"; then
+	  $show "${rm}r $gentop"
+	  $run ${rm}r $gentop
+	fi
+
+	exit $EXIT_SUCCESS
+      fi
+
+      if test "$build_libtool_libs" != yes; then
+	if test -n "$gentop"; then
+	  $show "${rm}r $gentop"
+	  $run ${rm}r $gentop
+	fi
+
+	# Create an invalid libtool object if no PIC, so that we don't
+	# accidentally link it into a program.
+	# $show "echo timestamp > $libobj"
+	# $run eval "echo timestamp > $libobj" || exit $?
+	exit $EXIT_SUCCESS
+      fi
+
+      if test -n "$pic_flag" || test "$pic_mode" != default; then
+	# Only do commands if we really have different PIC objects.
+	reload_objs="$libobjs $reload_conv_objs"
+	output="$libobj"
+	cmds=$reload_cmds
+	save_ifs="$IFS"; IFS='~'
+	for cmd in $cmds; do
+	  IFS="$save_ifs"
+	  eval cmd=\"$cmd\"
+	  $show "$cmd"
+	  $run eval "$cmd" || exit $?
+	done
+	IFS="$save_ifs"
+      fi
+
+      if test -n "$gentop"; then
+	$show "${rm}r $gentop"
+	$run ${rm}r $gentop
+      fi
+
+      exit $EXIT_SUCCESS
+      ;;
+
+    prog)
+      case $host in
+	*cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
+      esac
+      if test -n "$vinfo"; then
+	$echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
+      fi
+
+      if test -n "$release"; then
+	$echo "$modename: warning: \`-release' is ignored for programs" 1>&2
+      fi
+
+      if test "$preload" = yes; then
+	if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
+	   test "$dlopen_self_static" = unknown; then
+	  $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
+	fi
+      fi
+
+      case $host in
+      *-*-rhapsody* | *-*-darwin1.[012])
+	# On Rhapsody replace the C library is the System framework
+	compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
+	finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
+	;;
+      esac
+
+      case $host in
+      *darwin*)
+        # Don't allow lazy linking, it breaks C++ global constructors
+        if test "$tagname" = CXX ; then
+        compile_command="$compile_command ${wl}-bind_at_load"
+        finalize_command="$finalize_command ${wl}-bind_at_load"
+        fi
+        ;;
+      esac
+
+
+      # move library search paths that coincide with paths to not yet
+      # installed libraries to the beginning of the library search list
+      new_libs=
+      for path in $notinst_path; do
+	case " $new_libs " in
+	*" -L$path/$objdir "*) ;;
+	*)
+	  case " $compile_deplibs " in
+	  *" -L$path/$objdir "*)
+	    new_libs="$new_libs -L$path/$objdir" ;;
+	  esac
+	  ;;
+	esac
+      done
+      for deplib in $compile_deplibs; do
+	case $deplib in
+	-L*)
+	  case " $new_libs " in
+	  *" $deplib "*) ;;
+	  *) new_libs="$new_libs $deplib" ;;
+	  esac
+	  ;;
+	*) new_libs="$new_libs $deplib" ;;
+	esac
+      done
+      compile_deplibs="$new_libs"
+
+
+      compile_command="$compile_command $compile_deplibs"
+      finalize_command="$finalize_command $finalize_deplibs"
+
+      if test -n "$rpath$xrpath"; then
+	# If the user specified any rpath flags, then add them.
+	for libdir in $rpath $xrpath; do
+	  # This is the magic to use -rpath.
+	  case "$finalize_rpath " in
+	  *" $libdir "*) ;;
+	  *) finalize_rpath="$finalize_rpath $libdir" ;;
+	  esac
+	done
+      fi
+
+      # Now hardcode the library paths
+      rpath=
+      hardcode_libdirs=
+      for libdir in $compile_rpath $finalize_rpath; do
+	if test -n "$hardcode_libdir_flag_spec"; then
+	  if test -n "$hardcode_libdir_separator"; then
+	    if test -z "$hardcode_libdirs"; then
+	      hardcode_libdirs="$libdir"
+	    else
+	      # Just accumulate the unique libdirs.
+	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		;;
+	      *)
+		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
+		;;
+	      esac
+	    fi
+	  else
+	    eval flag=\"$hardcode_libdir_flag_spec\"
+	    rpath="$rpath $flag"
+	  fi
+	elif test -n "$runpath_var"; then
+	  case "$perm_rpath " in
+	  *" $libdir "*) ;;
+	  *) perm_rpath="$perm_rpath $libdir" ;;
+	  esac
+	fi
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
+	  testbindir=`$echo "X$libdir" | $Xsed -e 's*/lib$*/bin*'`
+	  case :$dllsearchpath: in
+	  *":$libdir:"*) ;;
+	  *) dllsearchpath="$dllsearchpath:$libdir";;
+	  esac
+	  case :$dllsearchpath: in
+	  *":$testbindir:"*) ;;
+	  *) dllsearchpath="$dllsearchpath:$testbindir";;
+	  esac
+	  ;;
+	esac
+      done
+      # Substitute the hardcoded libdirs into the rpath.
+      if test -n "$hardcode_libdir_separator" &&
+	 test -n "$hardcode_libdirs"; then
+	libdir="$hardcode_libdirs"
+	eval rpath=\" $hardcode_libdir_flag_spec\"
+      fi
+      compile_rpath="$rpath"
+
+      rpath=
+      hardcode_libdirs=
+      for libdir in $finalize_rpath; do
+	if test -n "$hardcode_libdir_flag_spec"; then
+	  if test -n "$hardcode_libdir_separator"; then
+	    if test -z "$hardcode_libdirs"; then
+	      hardcode_libdirs="$libdir"
+	    else
+	      # Just accumulate the unique libdirs.
+	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		;;
+	      *)
+		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
+		;;
+	      esac
+	    fi
+	  else
+	    eval flag=\"$hardcode_libdir_flag_spec\"
+	    rpath="$rpath $flag"
+	  fi
+	elif test -n "$runpath_var"; then
+	  case "$finalize_perm_rpath " in
+	  *" $libdir "*) ;;
+	  *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
+	  esac
+	fi
+      done
+      # Substitute the hardcoded libdirs into the rpath.
+      if test -n "$hardcode_libdir_separator" &&
+	 test -n "$hardcode_libdirs"; then
+	libdir="$hardcode_libdirs"
+	eval rpath=\" $hardcode_libdir_flag_spec\"
+      fi
+      finalize_rpath="$rpath"
+
+      if test -n "$libobjs" && test "$build_old_libs" = yes; then
+	# Transform all the library objects into standard objects.
+	compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+	finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+      fi
+
+      dlsyms=
+      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+	if test -n "$NM" && test -n "$global_symbol_pipe"; then
+	  dlsyms="${outputname}S.c"
+	else
+	  $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
+	fi
+      fi
+
+      if test -n "$dlsyms"; then
+	case $dlsyms in
+	"") ;;
+	*.c)
+	  # Discover the nlist of each of the dlfiles.
+	  nlist="$output_objdir/${outputname}.nm"
+
+	  $show "$rm $nlist ${nlist}S ${nlist}T"
+	  $run $rm "$nlist" "${nlist}S" "${nlist}T"
+
+	  # Parse the name list into a source file.
+	  $show "creating $output_objdir/$dlsyms"
+
+	  test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
+/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
+/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
+
+#ifdef __cplusplus
+extern \"C\" {
+#endif
+
+/* Prevent the only kind of declaration conflicts we can make. */
+#define lt_preloaded_symbols some_other_symbol
+
+/* External symbol declarations for the compiler. */\
+"
+
+	  if test "$dlself" = yes; then
+	    $show "generating symbol list for \`$output'"
+
+	    test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
+
+	    # Add our own program objects to the symbol list.
+	    progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+	    for arg in $progfiles; do
+	      $show "extracting global C symbols from \`$arg'"
+	      $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
+	    done
+
+	    if test -n "$exclude_expsyms"; then
+	      $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
+	      $run eval '$mv "$nlist"T "$nlist"'
+	    fi
+
+	    if test -n "$export_symbols_regex"; then
+	      $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
+	      $run eval '$mv "$nlist"T "$nlist"'
+	    fi
+
+	    # Prepare the list of exported symbols
+	    if test -z "$export_symbols"; then
+	      export_symbols="$output_objdir/$outputname.exp"
+	      $run $rm $export_symbols
+	      $run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
+              case $host in
+              *cygwin* | *mingw* )
+	        $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+		$run eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
+                ;;
+              esac
+	    else
+	      $run eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
+	      $run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
+	      $run eval 'mv "$nlist"T "$nlist"'
+              case $host in
+              *cygwin* | *mingw* )
+	        $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+		$run eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
+                ;;
+              esac
+	    fi
+	  fi
+
+	  for arg in $dlprefiles; do
+	    $show "extracting global C symbols from \`$arg'"
+	    name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
+	    $run eval '$echo ": $name " >> "$nlist"'
+	    $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
+	  done
+
+	  if test -z "$run"; then
+	    # Make sure we have at least an empty file.
+	    test -f "$nlist" || : > "$nlist"
+
+	    if test -n "$exclude_expsyms"; then
+	      $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
+	      $mv "$nlist"T "$nlist"
+	    fi
+
+	    # Try sorting and uniquifying the output.
+	    if grep -v "^: " < "$nlist" |
+		if sort -k 3 </dev/null >/dev/null 2>&1; then
+		  sort -k 3
+		else
+		  sort +2
+		fi |
+		uniq > "$nlist"S; then
+	      :
+	    else
+	      grep -v "^: " < "$nlist" > "$nlist"S
+	    fi
+
+	    if test -f "$nlist"S; then
+	      eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
+	    else
+	      $echo '/* NONE */' >> "$output_objdir/$dlsyms"
+	    fi
+
+	    $echo >> "$output_objdir/$dlsyms" "\
+
+#undef lt_preloaded_symbols
+
+#if defined (__STDC__) && __STDC__
+# define lt_ptr void *
+#else
+# define lt_ptr char *
+# define const
+#endif
+
+/* The mapping between symbol names and symbols. */
+"
+
+	    case $host in
+	    *cygwin* | *mingw* )
+	  $echo >> "$output_objdir/$dlsyms" "\
+/* DATA imports from DLLs on WIN32 can't be const, because
+   runtime relocations are performed -- see ld's documentation
+   on pseudo-relocs */
+struct {
+"
+	      ;;
+	    * )
+	  $echo >> "$output_objdir/$dlsyms" "\
+const struct {
+"
+	      ;;
+	    esac
+
+
+	  $echo >> "$output_objdir/$dlsyms" "\
+  const char *name;
+  lt_ptr address;
+}
+lt_preloaded_symbols[] =
+{\
+"
+
+	    eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
+
+	    $echo >> "$output_objdir/$dlsyms" "\
+  {0, (lt_ptr) 0}
+};
+
+/* This works around a problem in FreeBSD linker */
+#ifdef FREEBSD_WORKAROUND
+static const void *lt_preloaded_setup() {
+  return lt_preloaded_symbols;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif\
+"
+	  fi
+
+	  pic_flag_for_symtable=
+	  case $host in
+	  # compiling the symbol table file with pic_flag works around
+	  # a FreeBSD bug that causes programs to crash when -lm is
+	  # linked before any other PIC object.  But we must not use
+	  # pic_flag when linking with -static.  The problem exists in
+	  # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
+	  *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
+	    case "$compile_command " in
+	    *" -static "*) ;;
+	    *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
+	    esac;;
+	  *-*-hpux*)
+	    case "$compile_command " in
+	    *" -static "*) ;;
+	    *) pic_flag_for_symtable=" $pic_flag";;
+	    esac
+	  esac
+
+	  # Now compile the dynamic symbol file.
+	  $show "(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
+	  $run eval '(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
+
+	  # Clean up the generated files.
+	  $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
+	  $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
+
+	  # Transform the symbol file into the correct name.
+          case $host in
+          *cygwin* | *mingw* )
+            if test -f "$output_objdir/${outputname}.def" ; then
+              compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%"`
+              finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%"`
+            else
+              compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
+              finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
+             fi
+            ;;
+          * )
+            compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
+            finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
+            ;;
+          esac
+	  ;;
+	*)
+	  $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+      else
+	# We keep going just in case the user didn't refer to
+	# lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
+	# really was required.
+
+	# Nullify the symbol file.
+	compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
+	finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
+      fi
+
+      if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
+	# Replace the output file specification.
+	compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
+	link_command="$compile_command$compile_rpath"
+
+	# We have no uninstalled library dependencies, so finalize right now.
+	$show "$link_command"
+	$run eval "$link_command"
+	exit_status=$?
+
+	# Delete the generated files.
+	if test -n "$dlsyms"; then
+	  $show "$rm $output_objdir/${outputname}S.${objext}"
+	  $run $rm "$output_objdir/${outputname}S.${objext}"
+	fi
+
+	exit $exit_status
+      fi
+
+      if test -n "$shlibpath_var"; then
+	# We should set the shlibpath_var
+	rpath=
+	for dir in $temp_rpath; do
+	  case $dir in
+	  [\\/]* | [A-Za-z]:[\\/]*)
+	    # Absolute path.
+	    rpath="$rpath$dir:"
+	    ;;
+	  *)
+	    # Relative path: add a thisdir entry.
+	    rpath="$rpath\$thisdir/$dir:"
+	    ;;
+	  esac
+	done
+	temp_rpath="$rpath"
+      fi
+
+      if test -n "$compile_shlibpath$finalize_shlibpath"; then
+	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
+      fi
+      if test -n "$finalize_shlibpath"; then
+	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
+      fi
+
+      compile_var=
+      finalize_var=
+      if test -n "$runpath_var"; then
+	if test -n "$perm_rpath"; then
+	  # We should set the runpath_var.
+	  rpath=
+	  for dir in $perm_rpath; do
+	    rpath="$rpath$dir:"
+	  done
+	  compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
+	fi
+	if test -n "$finalize_perm_rpath"; then
+	  # We should set the runpath_var.
+	  rpath=
+	  for dir in $finalize_perm_rpath; do
+	    rpath="$rpath$dir:"
+	  done
+	  finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
+	fi
+      fi
+
+      if test "$no_install" = yes; then
+	# We don't need to create a wrapper script.
+	link_command="$compile_var$compile_command$compile_rpath"
+	# Replace the output file specification.
+	link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
+	# Delete the old output file.
+	$run $rm $output
+	# Link the executable and exit
+	$show "$link_command"
+	$run eval "$link_command" || exit $?
+	exit $EXIT_SUCCESS
+      fi
+
+      if test "$hardcode_action" = relink; then
+	# Fast installation is not supported
+	link_command="$compile_var$compile_command$compile_rpath"
+	relink_command="$finalize_var$finalize_command$finalize_rpath"
+
+	$echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
+	$echo "$modename: \`$output' will be relinked during installation" 1>&2
+      else
+	if test "$fast_install" != no; then
+	  link_command="$finalize_var$compile_command$finalize_rpath"
+	  if test "$fast_install" = yes; then
+	    relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
+	  else
+	    # fast_install is set to needless
+	    relink_command=
+	  fi
+	else
+	  link_command="$compile_var$compile_command$compile_rpath"
+	  relink_command="$finalize_var$finalize_command$finalize_rpath"
+	fi
+      fi
+
+      # Replace the output file specification.
+      link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
+
+      # Delete the old output files.
+      $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
+
+      $show "$link_command"
+      $run eval "$link_command" || exit $?
+
+      # Now create the wrapper script.
+      $show "creating $output"
+
+      # Quote the relink command for shipping.
+      if test -n "$relink_command"; then
+	# Preserve any variables that may affect compiler behavior
+	for var in $variables_saved_for_relink; do
+	  if eval test -z \"\${$var+set}\"; then
+	    relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
+	  elif eval var_value=\$$var; test -z "$var_value"; then
+	    relink_command="$var=; export $var; $relink_command"
+	  else
+	    var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
+	    relink_command="$var=\"$var_value\"; export $var; $relink_command"
+	  fi
+	done
+	relink_command="(cd `pwd`; $relink_command)"
+	relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
+      fi
+
+      # Quote $echo for shipping.
+      if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
+	case $progpath in
+	[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
+	*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
+	esac
+	qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
+      else
+	qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
+      fi
+
+      # Only actually do things if our run command is non-null.
+      if test -z "$run"; then
+	# win32 will think the script is a binary if it has
+	# a .exe suffix, so we strip it off here.
+	case $output in
+	  *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
+	esac
+	# test for cygwin because mv fails w/o .exe extensions
+	case $host in
+	  *cygwin*)
+	    exeext=.exe
+	    outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
+	  *) exeext= ;;
+	esac
+	case $host in
+	  *cygwin* | *mingw* )
+            output_name=`basename $output`
+            output_path=`dirname $output`
+            cwrappersource="$output_path/$objdir/lt-$output_name.c"
+            cwrapper="$output_path/$output_name.exe"
+            $rm $cwrappersource $cwrapper
+            trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
+
+	    cat > $cwrappersource <<EOF
+
+/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
+   Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
+
+   The $output program cannot be directly executed until all the libtool
+   libraries that it depends on are installed.
+
+   This wrapper executable should never be moved out of the build directory.
+   If it is, it will not operate correctly.
+
+   Currently, it simply execs the wrapper *script* "/bin/sh $output",
+   but could eventually absorb all of the scripts functionality and
+   exec $objdir/$outputname directly.
+*/
+EOF
+	    cat >> $cwrappersource<<"EOF"
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <malloc.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <string.h>
+#include <ctype.h>
+#include <sys/stat.h>
+
+#if defined(PATH_MAX)
+# define LT_PATHMAX PATH_MAX
+#elif defined(MAXPATHLEN)
+# define LT_PATHMAX MAXPATHLEN
+#else
+# define LT_PATHMAX 1024
+#endif
+
+#ifndef DIR_SEPARATOR
+# define DIR_SEPARATOR '/'
+# define PATH_SEPARATOR ':'
+#endif
+
+#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
+  defined (__OS2__)
+# define HAVE_DOS_BASED_FILE_SYSTEM
+# ifndef DIR_SEPARATOR_2
+#  define DIR_SEPARATOR_2 '\\'
+# endif
+# ifndef PATH_SEPARATOR_2
+#  define PATH_SEPARATOR_2 ';'
+# endif
+#endif
+
+#ifndef DIR_SEPARATOR_2
+# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
+#else /* DIR_SEPARATOR_2 */
+# define IS_DIR_SEPARATOR(ch) \
+        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
+#endif /* DIR_SEPARATOR_2 */
+
+#ifndef PATH_SEPARATOR_2
+# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
+#else /* PATH_SEPARATOR_2 */
+# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
+#endif /* PATH_SEPARATOR_2 */
+
+#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
+#define XFREE(stale) do { \
+  if (stale) { free ((void *) stale); stale = 0; } \
+} while (0)
+
+/* -DDEBUG is fairly common in CFLAGS.  */
+#undef DEBUG
+#if defined DEBUGWRAPPER
+# define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
+#else
+# define DEBUG(format, ...)
+#endif
+
+const char *program_name = NULL;
+
+void * xmalloc (size_t num);
+char * xstrdup (const char *string);
+const char * base_name (const char *name);
+char * find_executable(const char *wrapper);
+int    check_executable(const char *path);
+char * strendzap(char *str, const char *pat);
+void lt_fatal (const char *message, ...);
+
+int
+main (int argc, char *argv[])
+{
+  char **newargz;
+  int i;
+
+  program_name = (char *) xstrdup (base_name (argv[0]));
+  DEBUG("(main) argv[0]      : %s\n",argv[0]);
+  DEBUG("(main) program_name : %s\n",program_name);
+  newargz = XMALLOC(char *, argc+2);
+EOF
+
+            cat >> $cwrappersource <<EOF
+  newargz[0] = (char *) xstrdup("$SHELL");
+EOF
+
+            cat >> $cwrappersource <<"EOF"
+  newargz[1] = find_executable(argv[0]);
+  if (newargz[1] == NULL)
+    lt_fatal("Couldn't find %s", argv[0]);
+  DEBUG("(main) found exe at : %s\n",newargz[1]);
+  /* we know the script has the same name, without the .exe */
+  /* so make sure newargz[1] doesn't end in .exe */
+  strendzap(newargz[1],".exe");
+  for (i = 1; i < argc; i++)
+    newargz[i+1] = xstrdup(argv[i]);
+  newargz[argc+1] = NULL;
+
+  for (i=0; i<argc+1; i++)
+  {
+    DEBUG("(main) newargz[%d]   : %s\n",i,newargz[i]);
+    ;
+  }
+
+EOF
+
+            case $host_os in
+              mingw*)
+                cat >> $cwrappersource <<EOF
+  execv("$SHELL",(char const **)newargz);
+EOF
+              ;;
+              *)
+                cat >> $cwrappersource <<EOF
+  execv("$SHELL",newargz);
+EOF
+              ;;
+            esac
+
+            cat >> $cwrappersource <<"EOF"
+  return 127;
+}
+
+void *
+xmalloc (size_t num)
+{
+  void * p = (void *) malloc (num);
+  if (!p)
+    lt_fatal ("Memory exhausted");
+
+  return p;
+}
+
+char *
+xstrdup (const char *string)
+{
+  return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
+;
+}
+
+const char *
+base_name (const char *name)
+{
+  const char *base;
+
+#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+  /* Skip over the disk name in MSDOS pathnames. */
+  if (isalpha ((unsigned char)name[0]) && name[1] == ':')
+    name += 2;
+#endif
+
+  for (base = name; *name; name++)
+    if (IS_DIR_SEPARATOR (*name))
+      base = name + 1;
+  return base;
+}
+
+int
+check_executable(const char * path)
+{
+  struct stat st;
+
+  DEBUG("(check_executable)  : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
+  if ((!path) || (!*path))
+    return 0;
+
+  if ((stat (path, &st) >= 0) &&
+      (
+        /* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
+#if defined (S_IXOTH)
+       ((st.st_mode & S_IXOTH) == S_IXOTH) ||
+#endif
+#if defined (S_IXGRP)
+       ((st.st_mode & S_IXGRP) == S_IXGRP) ||
+#endif
+       ((st.st_mode & S_IXUSR) == S_IXUSR))
+      )
+    return 1;
+  else
+    return 0;
+}
+
+/* Searches for the full path of the wrapper.  Returns
+   newly allocated full path name if found, NULL otherwise */
+char *
+find_executable (const char* wrapper)
+{
+  int has_slash = 0;
+  const char* p;
+  const char* p_next;
+  /* static buffer for getcwd */
+  char tmp[LT_PATHMAX + 1];
+  int tmp_len;
+  char* concat_name;
+
+  DEBUG("(find_executable)  : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
+
+  if ((wrapper == NULL) || (*wrapper == '\0'))
+    return NULL;
+
+  /* Absolute path? */
+#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+  if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
+  {
+    concat_name = xstrdup (wrapper);
+    if (check_executable(concat_name))
+      return concat_name;
+    XFREE(concat_name);
+  }
+  else
+  {
+#endif
+    if (IS_DIR_SEPARATOR (wrapper[0]))
+    {
+      concat_name = xstrdup (wrapper);
+      if (check_executable(concat_name))
+        return concat_name;
+      XFREE(concat_name);
+    }
+#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+  }
+#endif
+
+  for (p = wrapper; *p; p++)
+    if (*p == '/')
+    {
+      has_slash = 1;
+      break;
+    }
+  if (!has_slash)
+  {
+    /* no slashes; search PATH */
+    const char* path = getenv ("PATH");
+    if (path != NULL)
+    {
+      for (p = path; *p; p = p_next)
+      {
+        const char* q;
+        size_t p_len;
+        for (q = p; *q; q++)
+          if (IS_PATH_SEPARATOR(*q))
+            break;
+        p_len = q - p;
+        p_next = (*q == '\0' ? q : q + 1);
+        if (p_len == 0)
+        {
+          /* empty path: current directory */
+          if (getcwd (tmp, LT_PATHMAX) == NULL)
+            lt_fatal ("getcwd failed");
+          tmp_len = strlen(tmp);
+          concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
+          memcpy (concat_name, tmp, tmp_len);
+          concat_name[tmp_len] = '/';
+          strcpy (concat_name + tmp_len + 1, wrapper);
+        }
+        else
+        {
+          concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
+          memcpy (concat_name, p, p_len);
+          concat_name[p_len] = '/';
+          strcpy (concat_name + p_len + 1, wrapper);
+        }
+        if (check_executable(concat_name))
+          return concat_name;
+        XFREE(concat_name);
+      }
+    }
+    /* not found in PATH; assume curdir */
+  }
+  /* Relative path | not found in path: prepend cwd */
+  if (getcwd (tmp, LT_PATHMAX) == NULL)
+    lt_fatal ("getcwd failed");
+  tmp_len = strlen(tmp);
+  concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
+  memcpy (concat_name, tmp, tmp_len);
+  concat_name[tmp_len] = '/';
+  strcpy (concat_name + tmp_len + 1, wrapper);
+
+  if (check_executable(concat_name))
+    return concat_name;
+  XFREE(concat_name);
+  return NULL;
+}
+
+char *
+strendzap(char *str, const char *pat)
+{
+  size_t len, patlen;
+
+  assert(str != NULL);
+  assert(pat != NULL);
+
+  len = strlen(str);
+  patlen = strlen(pat);
+
+  if (patlen <= len)
+  {
+    str += len - patlen;
+    if (strcmp(str, pat) == 0)
+      *str = '\0';
+  }
+  return str;
+}
+
+static void
+lt_error_core (int exit_status, const char * mode,
+          const char * message, va_list ap)
+{
+  fprintf (stderr, "%s: %s: ", program_name, mode);
+  vfprintf (stderr, message, ap);
+  fprintf (stderr, ".\n");
+
+  if (exit_status >= 0)
+    exit (exit_status);
+}
+
+void
+lt_fatal (const char *message, ...)
+{
+  va_list ap;
+  va_start (ap, message);
+  lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
+  va_end (ap);
+}
+EOF
+          # we should really use a build-platform specific compiler
+          # here, but OTOH, the wrappers (shell script and this C one)
+          # are only useful if you want to execute the "real" binary.
+          # Since the "real" binary is built for $host, then this
+          # wrapper might as well be built for $host, too.
+          $run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource
+          ;;
+        esac
+        $rm $output
+        trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
+
+	$echo > $output "\
+#! $SHELL
+
+# $output - temporary wrapper script for $objdir/$outputname
+# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
+#
+# The $output program cannot be directly executed until all the libtool
+# libraries that it depends on are installed.
+#
+# This wrapper script should never be moved out of the build directory.
+# If it is, it will not operate correctly.
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+Xsed='${SED} -e 1s/^X//'
+sed_quote_subst='$sed_quote_subst'
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+relink_command=\"$relink_command\"
+
+# This environment variable determines our operation mode.
+if test \"\$libtool_install_magic\" = \"$magic\"; then
+  # install mode needs the following variable:
+  notinst_deplibs='$notinst_deplibs'
+else
+  # When we are sourced in execute mode, \$file and \$echo are already set.
+  if test \"\$libtool_execute_magic\" != \"$magic\"; then
+    echo=\"$qecho\"
+    file=\"\$0\"
+    # Make sure echo works.
+    if test \"X\$1\" = X--no-reexec; then
+      # Discard the --no-reexec flag, and continue.
+      shift
+    elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
+      # Yippee, \$echo works!
+      :
+    else
+      # Restart under the correct shell, and then maybe \$echo will work.
+      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
+    fi
+  fi\
+"
+	$echo >> $output "\
+
+  # Find the directory that this script lives in.
+  thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
+  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
+
+  # Follow symbolic links until we get to the real thisdir.
+  file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
+  while test -n \"\$file\"; do
+    destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
+
+    # If there was a directory component, then change thisdir.
+    if test \"x\$destdir\" != \"x\$file\"; then
+      case \"\$destdir\" in
+      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
+      *) thisdir=\"\$thisdir/\$destdir\" ;;
+      esac
+    fi
+
+    file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
+    file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
+  done
+
+  # Try to get the absolute directory name.
+  absdir=\`cd \"\$thisdir\" && pwd\`
+  test -n \"\$absdir\" && thisdir=\"\$absdir\"
+"
+
+	if test "$fast_install" = yes; then
+	  $echo >> $output "\
+  program=lt-'$outputname'$exeext
+  progdir=\"\$thisdir/$objdir\"
+
+  if test ! -f \"\$progdir/\$program\" || \\
+     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
+       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
+
+    file=\"\$\$-\$program\"
+
+    if test ! -d \"\$progdir\"; then
+      $mkdir \"\$progdir\"
+    else
+      $rm \"\$progdir/\$file\"
+    fi"
+
+	  $echo >> $output "\
+
+    # relink executable if necessary
+    if test -n \"\$relink_command\"; then
+      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
+      else
+	$echo \"\$relink_command_output\" >&2
+	$rm \"\$progdir/\$file\"
+	exit $EXIT_FAILURE
+      fi
+    fi
+
+    $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
+    { $rm \"\$progdir/\$program\";
+      $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
+    $rm \"\$progdir/\$file\"
+  fi"
+	else
+	  $echo >> $output "\
+  program='$outputname'
+  progdir=\"\$thisdir/$objdir\"
+"
+	fi
+
+	$echo >> $output "\
+
+  if test -f \"\$progdir/\$program\"; then"
+
+	# Export our shlibpath_var if we have one.
+	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
+	  $echo >> $output "\
+    # Add our own library path to $shlibpath_var
+    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
+
+    # Some systems cannot cope with colon-terminated $shlibpath_var
+    # The second colon is a workaround for a bug in BeOS R4 sed
+    $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
+
+    export $shlibpath_var
+"
+	fi
+
+	# fixup the dll searchpath if we need to.
+	if test -n "$dllsearchpath"; then
+	  $echo >> $output "\
+    # Add the dll search path components to the executable PATH
+    PATH=$dllsearchpath:\$PATH
+"
+	fi
+
+	$echo >> $output "\
+    if test \"\$libtool_execute_magic\" != \"$magic\"; then
+      # Run the actual program with our arguments.
+"
+	case $host in
+	# Backslashes separate directories on plain windows
+	*-*-mingw | *-*-os2*)
+	  $echo >> $output "\
+      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
+"
+	  ;;
+
+	*)
+	  $echo >> $output "\
+      exec \"\$progdir/\$program\" \${1+\"\$@\"}
+"
+	  ;;
+	esac
+	$echo >> $output "\
+      \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
+      exit $EXIT_FAILURE
+    fi
+  else
+    # The program doesn't exist.
+    \$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
+    \$echo \"This script is just a wrapper for \$program.\" 1>&2
+    $echo \"See the $PACKAGE documentation for more information.\" 1>&2
+    exit $EXIT_FAILURE
+  fi
+fi\
+"
+	chmod +x $output
+      fi
+      exit $EXIT_SUCCESS
+      ;;
+    esac
+
+    # See if we need to build an old-fashioned archive.
+    for oldlib in $oldlibs; do
+
+      if test "$build_libtool_libs" = convenience; then
+	oldobjs="$libobjs_save"
+	addlibs="$convenience"
+	build_libtool_libs=no
+      else
+	if test "$build_libtool_libs" = module; then
+	  oldobjs="$libobjs_save"
+	  build_libtool_libs=no
+	else
+	  oldobjs="$old_deplibs $non_pic_objects"
+	fi
+	addlibs="$old_convenience"
+      fi
+
+      if test -n "$addlibs"; then
+	gentop="$output_objdir/${outputname}x"
+	generated="$generated $gentop"
+
+	func_extract_archives $gentop $addlibs
+	oldobjs="$oldobjs $func_extract_archives_result"
+      fi
+
+      # Do each command in the archive commands.
+      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
+       cmds=$old_archive_from_new_cmds
+      else
+	# POSIX demands no paths to be encoded in archives.  We have
+	# to avoid creating archives with duplicate basenames if we
+	# might have to extract them afterwards, e.g., when creating a
+	# static archive out of a convenience library, or when linking
+	# the entirety of a libtool archive into another (currently
+	# not supported by libtool).
+	if (for obj in $oldobjs
+	    do
+	      $echo "X$obj" | $Xsed -e 's%^.*/%%'
+	    done | sort | sort -uc >/dev/null 2>&1); then
+	  :
+	else
+	  $echo "copying selected object files to avoid basename conflicts..."
+
+	  if test -z "$gentop"; then
+	    gentop="$output_objdir/${outputname}x"
+	    generated="$generated $gentop"
+
+	    $show "${rm}r $gentop"
+	    $run ${rm}r "$gentop"
+	    $show "$mkdir $gentop"
+	    $run $mkdir "$gentop"
+	    exit_status=$?
+	    if test "$exit_status" -ne 0 && test ! -d "$gentop"; then
+	      exit $exit_status
+	    fi
+	  fi
+
+	  save_oldobjs=$oldobjs
+	  oldobjs=
+	  counter=1
+	  for obj in $save_oldobjs
+	  do
+	    objbase=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
+	    case " $oldobjs " in
+	    " ") oldobjs=$obj ;;
+	    *[\ /]"$objbase "*)
+	      while :; do
+		# Make sure we don't pick an alternate name that also
+		# overlaps.
+		newobj=lt$counter-$objbase
+		counter=`expr $counter + 1`
+		case " $oldobjs " in
+		*[\ /]"$newobj "*) ;;
+		*) if test ! -f "$gentop/$newobj"; then break; fi ;;
+		esac
+	      done
+	      $show "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
+	      $run ln "$obj" "$gentop/$newobj" ||
+	      $run cp "$obj" "$gentop/$newobj"
+	      oldobjs="$oldobjs $gentop/$newobj"
+	      ;;
+	    *) oldobjs="$oldobjs $obj" ;;
+	    esac
+	  done
+	fi
+
+	eval cmds=\"$old_archive_cmds\"
+
+	if len=`expr "X$cmds" : ".*"` &&
+	     test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+	  cmds=$old_archive_cmds
+	else
+	  # the command line is too long to link in one step, link in parts
+	  $echo "using piecewise archive linking..."
+	  save_RANLIB=$RANLIB
+	  RANLIB=:
+	  objlist=
+	  concat_cmds=
+	  save_oldobjs=$oldobjs
+
+	  # Is there a better way of finding the last object in the list?
+	  for obj in $save_oldobjs
+	  do
+	    last_oldobj=$obj
+	  done
+	  for obj in $save_oldobjs
+	  do
+	    oldobjs="$objlist $obj"
+	    objlist="$objlist $obj"
+	    eval test_cmds=\"$old_archive_cmds\"
+	    if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
+	       test "$len" -le "$max_cmd_len"; then
+	      :
+	    else
+	      # the above command should be used before it gets too long
+	      oldobjs=$objlist
+	      if test "$obj" = "$last_oldobj" ; then
+	        RANLIB=$save_RANLIB
+	      fi
+	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+	      eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
+	      objlist=
+	    fi
+	  done
+	  RANLIB=$save_RANLIB
+	  oldobjs=$objlist
+	  if test "X$oldobjs" = "X" ; then
+	    eval cmds=\"\$concat_cmds\"
+	  else
+	    eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
+	  fi
+	fi
+      fi
+      save_ifs="$IFS"; IFS='~'
+      for cmd in $cmds; do
+        eval cmd=\"$cmd\"
+	IFS="$save_ifs"
+	$show "$cmd"
+	$run eval "$cmd" || exit $?
+      done
+      IFS="$save_ifs"
+    done
+
+    if test -n "$generated"; then
+      $show "${rm}r$generated"
+      $run ${rm}r$generated
+    fi
+
+    # Now create the libtool archive.
+    case $output in
+    *.la)
+      old_library=
+      test "$build_old_libs" = yes && old_library="$libname.$libext"
+      $show "creating $output"
+
+      # Preserve any variables that may affect compiler behavior
+      for var in $variables_saved_for_relink; do
+	if eval test -z \"\${$var+set}\"; then
+	  relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
+	elif eval var_value=\$$var; test -z "$var_value"; then
+	  relink_command="$var=; export $var; $relink_command"
+	else
+	  var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
+	  relink_command="$var=\"$var_value\"; export $var; $relink_command"
+	fi
+      done
+      # Quote the link command for shipping.
+      relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
+      relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
+      if test "$hardcode_automatic" = yes ; then
+	relink_command=
+      fi
+
+
+      # Only create the output if not a dry run.
+      if test -z "$run"; then
+	for installed in no yes; do
+	  if test "$installed" = yes; then
+	    if test -z "$install_libdir"; then
+	      break
+	    fi
+	    output="$output_objdir/$outputname"i
+	    # Replace all uninstalled libtool libraries with the installed ones
+	    newdependency_libs=
+	    for deplib in $dependency_libs; do
+	      case $deplib in
+	      *.la)
+		name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
+		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
+		if test -z "$libdir"; then
+		  $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
+		  exit $EXIT_FAILURE
+		fi
+		newdependency_libs="$newdependency_libs $libdir/$name"
+		;;
+	      *) newdependency_libs="$newdependency_libs $deplib" ;;
+	      esac
+	    done
+	    dependency_libs="$newdependency_libs"
+	    newdlfiles=
+	    for lib in $dlfiles; do
+	      name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
+	      eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
+	      if test -z "$libdir"; then
+		$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
+		exit $EXIT_FAILURE
+	      fi
+	      newdlfiles="$newdlfiles $libdir/$name"
+	    done
+	    dlfiles="$newdlfiles"
+	    newdlprefiles=
+	    for lib in $dlprefiles; do
+	      name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
+	      eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
+	      if test -z "$libdir"; then
+		$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
+		exit $EXIT_FAILURE
+	      fi
+	      newdlprefiles="$newdlprefiles $libdir/$name"
+	    done
+	    dlprefiles="$newdlprefiles"
+	  else
+	    newdlfiles=
+	    for lib in $dlfiles; do
+	      case $lib in
+		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
+		*) abs=`pwd`"/$lib" ;;
+	      esac
+	      newdlfiles="$newdlfiles $abs"
+	    done
+	    dlfiles="$newdlfiles"
+	    newdlprefiles=
+	    for lib in $dlprefiles; do
+	      case $lib in
+		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
+		*) abs=`pwd`"/$lib" ;;
+	      esac
+	      newdlprefiles="$newdlprefiles $abs"
+	    done
+	    dlprefiles="$newdlprefiles"
+	  fi
+	  $rm $output
+	  # place dlname in correct position for cygwin
+	  tdlname=$dlname
+	  case $host,$output,$installed,$module,$dlname in
+	    *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
+	  esac
+	  $echo > $output "\
+# $outputname - a libtool library file
+# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# The name that we can dlopen(3).
+dlname='$tdlname'
+
+# Names of this library.
+library_names='$library_names'
+
+# The name of the static archive.
+old_library='$old_library'
+
+# Libraries that this one depends upon.
+dependency_libs='$dependency_libs'
+
+# Version information for $libname.
+current=$current
+age=$age
+revision=$revision
+
+# Is this an already installed library?
+installed=$installed
+
+# Should we warn about portability when linking against -modules?
+shouldnotlink=$module
+
+# Files to dlopen/dlpreopen
+dlopen='$dlfiles'
+dlpreopen='$dlprefiles'
+
+# Directory that this library needs to be installed in:
+libdir='$install_libdir'"
+	  if test "$installed" = no && test "$need_relink" = yes; then
+	    $echo >> $output "\
+relink_command=\"$relink_command\""
+	  fi
+	done
+      fi
+
+      # Do a symbolic link so that the libtool archive can be found in
+      # LD_LIBRARY_PATH before the program is installed.
+      $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
+      $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
+      ;;
+    esac
+    exit $EXIT_SUCCESS
+    ;;
+
+  # libtool install mode
+  install)
+    modename="$modename: install"
+
+    # There may be an optional sh(1) argument at the beginning of
+    # install_prog (especially on Windows NT).
+    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
+       # Allow the use of GNU shtool's install command.
+       $echo "X$nonopt" | grep shtool > /dev/null; then
+      # Aesthetically quote it.
+      arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
+      case $arg in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	arg="\"$arg\""
+	;;
+      esac
+      install_prog="$arg "
+      arg="$1"
+      shift
+    else
+      install_prog=
+      arg=$nonopt
+    fi
+
+    # The real first argument should be the name of the installation program.
+    # Aesthetically quote it.
+    arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+    case $arg in
+    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+      arg="\"$arg\""
+      ;;
+    esac
+    install_prog="$install_prog$arg"
+
+    # We need to accept at least all the BSD install flags.
+    dest=
+    files=
+    opts=
+    prev=
+    install_type=
+    isdir=no
+    stripme=
+    for arg
+    do
+      if test -n "$dest"; then
+	files="$files $dest"
+	dest=$arg
+	continue
+      fi
+
+      case $arg in
+      -d) isdir=yes ;;
+      -f) 
+      	case " $install_prog " in
+	*[\\\ /]cp\ *) ;;
+	*) prev=$arg ;;
+	esac
+	;;
+      -g | -m | -o) prev=$arg ;;
+      -s)
+	stripme=" -s"
+	continue
+	;;
+      -*)
+	;;
+      *)
+	# If the previous option needed an argument, then skip it.
+	if test -n "$prev"; then
+	  prev=
+	else
+	  dest=$arg
+	  continue
+	fi
+	;;
+      esac
+
+      # Aesthetically quote the argument.
+      arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+      case $arg in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	arg="\"$arg\""
+	;;
+      esac
+      install_prog="$install_prog $arg"
+    done
+
+    if test -z "$install_prog"; then
+      $echo "$modename: you must specify an install program" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    if test -n "$prev"; then
+      $echo "$modename: the \`$prev' option requires an argument" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    if test -z "$files"; then
+      if test -z "$dest"; then
+	$echo "$modename: no file or destination specified" 1>&2
+      else
+	$echo "$modename: you must specify a destination" 1>&2
+      fi
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    # Strip any trailing slash from the destination.
+    dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
+
+    # Check to see that the destination is a directory.
+    test -d "$dest" && isdir=yes
+    if test "$isdir" = yes; then
+      destdir="$dest"
+      destname=
+    else
+      destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
+      test "X$destdir" = "X$dest" && destdir=.
+      destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
+
+      # Not a directory, so check to see that there is only one file specified.
+      set dummy $files
+      if test "$#" -gt 2; then
+	$echo "$modename: \`$dest' is not a directory" 1>&2
+	$echo "$help" 1>&2
+	exit $EXIT_FAILURE
+      fi
+    fi
+    case $destdir in
+    [\\/]* | [A-Za-z]:[\\/]*) ;;
+    *)
+      for file in $files; do
+	case $file in
+	*.lo) ;;
+	*)
+	  $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+      done
+      ;;
+    esac
+
+    # This variable tells wrapper scripts just to set variables rather
+    # than running their programs.
+    libtool_install_magic="$magic"
+
+    staticlibs=
+    future_libdirs=
+    current_libdirs=
+    for file in $files; do
+
+      # Do each installation.
+      case $file in
+      *.$libext)
+	# Do the static libraries later.
+	staticlibs="$staticlibs $file"
+	;;
+
+      *.la)
+	# Check to see that this really is a libtool archive.
+	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
+	else
+	  $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	library_names=
+	old_library=
+	relink_command=
+	# If there is no directory component, then add one.
+	case $file in
+	*/* | *\\*) . $file ;;
+	*) . ./$file ;;
+	esac
+
+	# Add the libdir to current_libdirs if it is the destination.
+	if test "X$destdir" = "X$libdir"; then
+	  case "$current_libdirs " in
+	  *" $libdir "*) ;;
+	  *) current_libdirs="$current_libdirs $libdir" ;;
+	  esac
+	else
+	  # Note the libdir as a future libdir.
+	  case "$future_libdirs " in
+	  *" $libdir "*) ;;
+	  *) future_libdirs="$future_libdirs $libdir" ;;
+	  esac
+	fi
+
+	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
+	test "X$dir" = "X$file/" && dir=
+	dir="$dir$objdir"
+
+	if test -n "$relink_command"; then
+	  # Determine the prefix the user has applied to our future dir.
+	  inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
+
+	  # Don't allow the user to place us outside of our expected
+	  # location b/c this prevents finding dependent libraries that
+	  # are installed to the same prefix.
+	  # At present, this check doesn't affect windows .dll's that
+	  # are installed into $libdir/../bin (currently, that works fine)
+	  # but it's something to keep an eye on.
+	  if test "$inst_prefix_dir" = "$destdir"; then
+	    $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+
+	  if test -n "$inst_prefix_dir"; then
+	    # Stick the inst_prefix_dir data into the link command.
+	    relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
+	  else
+	    relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
+	  fi
+
+	  $echo "$modename: warning: relinking \`$file'" 1>&2
+	  $show "$relink_command"
+	  if $run eval "$relink_command"; then :
+	  else
+	    $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+	fi
+
+	# See the names of the shared library.
+	set dummy $library_names
+	if test -n "$2"; then
+	  realname="$2"
+	  shift
+	  shift
+
+	  srcname="$realname"
+	  test -n "$relink_command" && srcname="$realname"T
+
+	  # Install the shared library and build the symlinks.
+	  $show "$install_prog $dir/$srcname $destdir/$realname"
+	  $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
+	  if test -n "$stripme" && test -n "$striplib"; then
+	    $show "$striplib $destdir/$realname"
+	    $run eval "$striplib $destdir/$realname" || exit $?
+	  fi
+
+	  if test "$#" -gt 0; then
+	    # Delete the old symlinks, and create new ones.
+	    # Try `ln -sf' first, because the `ln' binary might depend on
+	    # the symlink we replace!  Solaris /bin/ln does not understand -f,
+	    # so we also need to try rm && ln -s.
+	    for linkname
+	    do
+	      if test "$linkname" != "$realname"; then
+                $show "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
+                $run eval "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
+	      fi
+	    done
+	  fi
+
+	  # Do each command in the postinstall commands.
+	  lib="$destdir/$realname"
+	  cmds=$postinstall_cmds
+	  save_ifs="$IFS"; IFS='~'
+	  for cmd in $cmds; do
+	    IFS="$save_ifs"
+	    eval cmd=\"$cmd\"
+	    $show "$cmd"
+	    $run eval "$cmd" || {
+	      lt_exit=$?
+
+	      # Restore the uninstalled library and exit
+	      if test "$mode" = relink; then
+		$run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
+	      fi
+
+	      exit $lt_exit
+	    }
+	  done
+	  IFS="$save_ifs"
+	fi
+
+	# Install the pseudo-library for information purposes.
+	name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+	instname="$dir/$name"i
+	$show "$install_prog $instname $destdir/$name"
+	$run eval "$install_prog $instname $destdir/$name" || exit $?
+
+	# Maybe install the static library, too.
+	test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
+	;;
+
+      *.lo)
+	# Install (i.e. copy) a libtool object.
+
+	# Figure out destination file name, if it wasn't already specified.
+	if test -n "$destname"; then
+	  destfile="$destdir/$destname"
+	else
+	  destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+	  destfile="$destdir/$destfile"
+	fi
+
+	# Deduce the name of the destination old-style object file.
+	case $destfile in
+	*.lo)
+	  staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
+	  ;;
+	*.$objext)
+	  staticdest="$destfile"
+	  destfile=
+	  ;;
+	*)
+	  $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+
+	# Install the libtool object if requested.
+	if test -n "$destfile"; then
+	  $show "$install_prog $file $destfile"
+	  $run eval "$install_prog $file $destfile" || exit $?
+	fi
+
+	# Install the old object if enabled.
+	if test "$build_old_libs" = yes; then
+	  # Deduce the name of the old-style object file.
+	  staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
+
+	  $show "$install_prog $staticobj $staticdest"
+	  $run eval "$install_prog \$staticobj \$staticdest" || exit $?
+	fi
+	exit $EXIT_SUCCESS
+	;;
+
+      *)
+	# Figure out destination file name, if it wasn't already specified.
+	if test -n "$destname"; then
+	  destfile="$destdir/$destname"
+	else
+	  destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+	  destfile="$destdir/$destfile"
+	fi
+
+	# If the file is missing, and there is a .exe on the end, strip it
+	# because it is most likely a libtool script we actually want to
+	# install
+	stripped_ext=""
+	case $file in
+	  *.exe)
+	    if test ! -f "$file"; then
+	      file=`$echo $file|${SED} 's,.exe$,,'`
+	      stripped_ext=".exe"
+	    fi
+	    ;;
+	esac
+
+	# Do a test to see if this is really a libtool program.
+	case $host in
+	*cygwin*|*mingw*)
+	    wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
+	    ;;
+	*)
+	    wrapper=$file
+	    ;;
+	esac
+	if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
+	  notinst_deplibs=
+	  relink_command=
+
+	  # Note that it is not necessary on cygwin/mingw to append a dot to
+	  # foo even if both foo and FILE.exe exist: automatic-append-.exe
+	  # behavior happens only for exec(3), not for open(2)!  Also, sourcing
+	  # `FILE.' does not work on cygwin managed mounts.
+	  #
+	  # If there is no directory component, then add one.
+	  case $wrapper in
+	  */* | *\\*) . ${wrapper} ;;
+	  *) . ./${wrapper} ;;
+	  esac
+
+	  # Check the variables that should have been set.
+	  if test -z "$notinst_deplibs"; then
+	    $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+
+	  finalize=yes
+	  for lib in $notinst_deplibs; do
+	    # Check to see that each library is installed.
+	    libdir=
+	    if test -f "$lib"; then
+	      # If there is no directory component, then add one.
+	      case $lib in
+	      */* | *\\*) . $lib ;;
+	      *) . ./$lib ;;
+	      esac
+	    fi
+	    libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
+	    if test -n "$libdir" && test ! -f "$libfile"; then
+	      $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
+	      finalize=no
+	    fi
+	  done
+
+	  relink_command=
+	  # Note that it is not necessary on cygwin/mingw to append a dot to
+	  # foo even if both foo and FILE.exe exist: automatic-append-.exe
+	  # behavior happens only for exec(3), not for open(2)!  Also, sourcing
+	  # `FILE.' does not work on cygwin managed mounts.
+	  #
+	  # If there is no directory component, then add one.
+	  case $wrapper in
+	  */* | *\\*) . ${wrapper} ;;
+	  *) . ./${wrapper} ;;
+	  esac
+
+	  outputname=
+	  if test "$fast_install" = no && test -n "$relink_command"; then
+	    if test "$finalize" = yes && test -z "$run"; then
+	      tmpdir=`func_mktempdir`
+	      file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
+	      outputname="$tmpdir/$file"
+	      # Replace the output file specification.
+	      relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
+
+	      $show "$relink_command"
+	      if $run eval "$relink_command"; then :
+	      else
+		$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
+		${rm}r "$tmpdir"
+		continue
+	      fi
+	      file="$outputname"
+	    else
+	      $echo "$modename: warning: cannot relink \`$file'" 1>&2
+	    fi
+	  else
+	    # Install the binary that we compiled earlier.
+	    file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
+	  fi
+	fi
+
+	# remove .exe since cygwin /usr/bin/install will append another
+	# one anyway 
+	case $install_prog,$host in
+	*/usr/bin/install*,*cygwin*)
+	  case $file:$destfile in
+	  *.exe:*.exe)
+	    # this is ok
+	    ;;
+	  *.exe:*)
+	    destfile=$destfile.exe
+	    ;;
+	  *:*.exe)
+	    destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
+	    ;;
+	  esac
+	  ;;
+	esac
+	$show "$install_prog$stripme $file $destfile"
+	$run eval "$install_prog\$stripme \$file \$destfile" || exit $?
+	test -n "$outputname" && ${rm}r "$tmpdir"
+	;;
+      esac
+    done
+
+    for file in $staticlibs; do
+      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+
+      # Set up the ranlib parameters.
+      oldlib="$destdir/$name"
+
+      $show "$install_prog $file $oldlib"
+      $run eval "$install_prog \$file \$oldlib" || exit $?
+
+      if test -n "$stripme" && test -n "$old_striplib"; then
+	$show "$old_striplib $oldlib"
+	$run eval "$old_striplib $oldlib" || exit $?
+      fi
+
+      # Do each command in the postinstall commands.
+      cmds=$old_postinstall_cmds
+      save_ifs="$IFS"; IFS='~'
+      for cmd in $cmds; do
+	IFS="$save_ifs"
+	eval cmd=\"$cmd\"
+	$show "$cmd"
+	$run eval "$cmd" || exit $?
+      done
+      IFS="$save_ifs"
+    done
+
+    if test -n "$future_libdirs"; then
+      $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
+    fi
+
+    if test -n "$current_libdirs"; then
+      # Maybe just do a dry run.
+      test -n "$run" && current_libdirs=" -n$current_libdirs"
+      exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
+    else
+      exit $EXIT_SUCCESS
+    fi
+    ;;
+
+  # libtool finish mode
+  finish)
+    modename="$modename: finish"
+    libdirs="$nonopt"
+    admincmds=
+
+    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
+      for dir
+      do
+	libdirs="$libdirs $dir"
+      done
+
+      for libdir in $libdirs; do
+	if test -n "$finish_cmds"; then
+	  # Do each command in the finish commands.
+	  cmds=$finish_cmds
+	  save_ifs="$IFS"; IFS='~'
+	  for cmd in $cmds; do
+	    IFS="$save_ifs"
+	    eval cmd=\"$cmd\"
+	    $show "$cmd"
+	    $run eval "$cmd" || admincmds="$admincmds
+       $cmd"
+	  done
+	  IFS="$save_ifs"
+	fi
+	if test -n "$finish_eval"; then
+	  # Do the single finish_eval.
+	  eval cmds=\"$finish_eval\"
+	  $run eval "$cmds" || admincmds="$admincmds
+       $cmds"
+	fi
+      done
+    fi
+
+    # Exit here if they wanted silent mode.
+    test "$show" = : && exit $EXIT_SUCCESS
+
+    $echo "X----------------------------------------------------------------------" | $Xsed
+    $echo "Libraries have been installed in:"
+    for libdir in $libdirs; do
+      $echo "   $libdir"
+    done
+    $echo
+    $echo "If you ever happen to want to link against installed libraries"
+    $echo "in a given directory, LIBDIR, you must either use libtool, and"
+    $echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
+    $echo "flag during linking and do at least one of the following:"
+    if test -n "$shlibpath_var"; then
+      $echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
+      $echo "     during execution"
+    fi
+    if test -n "$runpath_var"; then
+      $echo "   - add LIBDIR to the \`$runpath_var' environment variable"
+      $echo "     during linking"
+    fi
+    if test -n "$hardcode_libdir_flag_spec"; then
+      libdir=LIBDIR
+      eval flag=\"$hardcode_libdir_flag_spec\"
+
+      $echo "   - use the \`$flag' linker flag"
+    fi
+    if test -n "$admincmds"; then
+      $echo "   - have your system administrator run these commands:$admincmds"
+    fi
+    if test -f /etc/ld.so.conf; then
+      $echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
+    fi
+    $echo
+    $echo "See any operating system documentation about shared libraries for"
+    $echo "more information, such as the ld(1) and ld.so(8) manual pages."
+    $echo "X----------------------------------------------------------------------" | $Xsed
+    exit $EXIT_SUCCESS
+    ;;
+
+  # libtool execute mode
+  execute)
+    modename="$modename: execute"
+
+    # The first argument is the command name.
+    cmd="$nonopt"
+    if test -z "$cmd"; then
+      $echo "$modename: you must specify a COMMAND" 1>&2
+      $echo "$help"
+      exit $EXIT_FAILURE
+    fi
+
+    # Handle -dlopen flags immediately.
+    for file in $execute_dlfiles; do
+      if test ! -f "$file"; then
+	$echo "$modename: \`$file' is not a file" 1>&2
+	$echo "$help" 1>&2
+	exit $EXIT_FAILURE
+      fi
+
+      dir=
+      case $file in
+      *.la)
+	# Check to see that this really is a libtool archive.
+	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
+	else
+	  $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	# Read the libtool library.
+	dlname=
+	library_names=
+
+	# If there is no directory component, then add one.
+	case $file in
+	*/* | *\\*) . $file ;;
+	*) . ./$file ;;
+	esac
+
+	# Skip this library if it cannot be dlopened.
+	if test -z "$dlname"; then
+	  # Warn if it was a shared library.
+	  test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
+	  continue
+	fi
+
+	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
+	test "X$dir" = "X$file" && dir=.
+
+	if test -f "$dir/$objdir/$dlname"; then
+	  dir="$dir/$objdir"
+	else
+	  $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+	;;
+
+      *.lo)
+	# Just add the directory containing the .lo file.
+	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
+	test "X$dir" = "X$file" && dir=.
+	;;
+
+      *)
+	$echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
+	continue
+	;;
+      esac
+
+      # Get the absolute pathname.
+      absdir=`cd "$dir" && pwd`
+      test -n "$absdir" && dir="$absdir"
+
+      # Now add the directory to shlibpath_var.
+      if eval "test -z \"\$$shlibpath_var\""; then
+	eval "$shlibpath_var=\"\$dir\""
+      else
+	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
+      fi
+    done
+
+    # This variable tells wrapper scripts just to set shlibpath_var
+    # rather than running their programs.
+    libtool_execute_magic="$magic"
+
+    # Check if any of the arguments is a wrapper script.
+    args=
+    for file
+    do
+      case $file in
+      -*) ;;
+      *)
+	# Do a test to see if this is really a libtool program.
+	if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+	  # If there is no directory component, then add one.
+	  case $file in
+	  */* | *\\*) . $file ;;
+	  *) . ./$file ;;
+	  esac
+
+	  # Transform arg to wrapped name.
+	  file="$progdir/$program"
+	fi
+	;;
+      esac
+      # Quote arguments (to preserve shell metacharacters).
+      file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
+      args="$args \"$file\""
+    done
+
+    if test -z "$run"; then
+      if test -n "$shlibpath_var"; then
+	# Export the shlibpath_var.
+	eval "export $shlibpath_var"
+      fi
+
+      # Restore saved environment variables
+      if test "${save_LC_ALL+set}" = set; then
+	LC_ALL="$save_LC_ALL"; export LC_ALL
+      fi
+      if test "${save_LANG+set}" = set; then
+	LANG="$save_LANG"; export LANG
+      fi
+
+      # Now prepare to actually exec the command.
+      exec_cmd="\$cmd$args"
+    else
+      # Display what would be done.
+      if test -n "$shlibpath_var"; then
+	eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
+	$echo "export $shlibpath_var"
+      fi
+      $echo "$cmd$args"
+      exit $EXIT_SUCCESS
+    fi
+    ;;
+
+  # libtool clean and uninstall mode
+  clean | uninstall)
+    modename="$modename: $mode"
+    rm="$nonopt"
+    files=
+    rmforce=
+    exit_status=0
+
+    # This variable tells wrapper scripts just to set variables rather
+    # than running their programs.
+    libtool_install_magic="$magic"
+
+    for arg
+    do
+      case $arg in
+      -f) rm="$rm $arg"; rmforce=yes ;;
+      -*) rm="$rm $arg" ;;
+      *) files="$files $arg" ;;
+      esac
+    done
+
+    if test -z "$rm"; then
+      $echo "$modename: you must specify an RM program" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    rmdirs=
+
+    origobjdir="$objdir"
+    for file in $files; do
+      dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
+      if test "X$dir" = "X$file"; then
+	dir=.
+	objdir="$origobjdir"
+      else
+	objdir="$dir/$origobjdir"
+      fi
+      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+      test "$mode" = uninstall && objdir="$dir"
+
+      # Remember objdir for removal later, being careful to avoid duplicates
+      if test "$mode" = clean; then
+	case " $rmdirs " in
+	  *" $objdir "*) ;;
+	  *) rmdirs="$rmdirs $objdir" ;;
+	esac
+      fi
+
+      # Don't error if the file doesn't exist and rm -f was used.
+      if (test -L "$file") >/dev/null 2>&1 \
+	|| (test -h "$file") >/dev/null 2>&1 \
+	|| test -f "$file"; then
+	:
+      elif test -d "$file"; then
+	exit_status=1
+	continue
+      elif test "$rmforce" = yes; then
+	continue
+      fi
+
+      rmfiles="$file"
+
+      case $name in
+      *.la)
+	# Possibly a libtool archive, so verify it.
+	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+	  . $dir/$name
+
+	  # Delete the libtool libraries and symlinks.
+	  for n in $library_names; do
+	    rmfiles="$rmfiles $objdir/$n"
+	  done
+	  test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
+
+	  case "$mode" in
+	  clean)
+	    case "  $library_names " in
+	    # "  " in the beginning catches empty $dlname
+	    *" $dlname "*) ;;
+	    *) rmfiles="$rmfiles $objdir/$dlname" ;;
+	    esac
+	     test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
+	    ;;
+	  uninstall)
+	    if test -n "$library_names"; then
+	      # Do each command in the postuninstall commands.
+	      cmds=$postuninstall_cmds
+	      save_ifs="$IFS"; IFS='~'
+	      for cmd in $cmds; do
+		IFS="$save_ifs"
+		eval cmd=\"$cmd\"
+		$show "$cmd"
+		$run eval "$cmd"
+		if test "$?" -ne 0 && test "$rmforce" != yes; then
+		  exit_status=1
+		fi
+	      done
+	      IFS="$save_ifs"
+	    fi
+
+	    if test -n "$old_library"; then
+	      # Do each command in the old_postuninstall commands.
+	      cmds=$old_postuninstall_cmds
+	      save_ifs="$IFS"; IFS='~'
+	      for cmd in $cmds; do
+		IFS="$save_ifs"
+		eval cmd=\"$cmd\"
+		$show "$cmd"
+		$run eval "$cmd"
+		if test "$?" -ne 0 && test "$rmforce" != yes; then
+		  exit_status=1
+		fi
+	      done
+	      IFS="$save_ifs"
+	    fi
+	    # FIXME: should reinstall the best remaining shared library.
+	    ;;
+	  esac
+	fi
+	;;
+
+      *.lo)
+	# Possibly a libtool object, so verify it.
+	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+
+	  # Read the .lo file
+	  . $dir/$name
+
+	  # Add PIC object to the list of files to remove.
+	  if test -n "$pic_object" \
+	     && test "$pic_object" != none; then
+	    rmfiles="$rmfiles $dir/$pic_object"
+	  fi
+
+	  # Add non-PIC object to the list of files to remove.
+	  if test -n "$non_pic_object" \
+	     && test "$non_pic_object" != none; then
+	    rmfiles="$rmfiles $dir/$non_pic_object"
+	  fi
+	fi
+	;;
+
+      *)
+	if test "$mode" = clean ; then
+	  noexename=$name
+	  case $file in
+	  *.exe)
+	    file=`$echo $file|${SED} 's,.exe$,,'`
+	    noexename=`$echo $name|${SED} 's,.exe$,,'`
+	    # $file with .exe has already been added to rmfiles,
+	    # add $file without .exe
+	    rmfiles="$rmfiles $file"
+	    ;;
+	  esac
+	  # Do a test to see if this is a libtool program.
+	  if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+	    relink_command=
+	    . $dir/$noexename
+
+	    # note $name still contains .exe if it was in $file originally
+	    # as does the version of $file that was added into $rmfiles
+	    rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
+	    if test "$fast_install" = yes && test -n "$relink_command"; then
+	      rmfiles="$rmfiles $objdir/lt-$name"
+	    fi
+	    if test "X$noexename" != "X$name" ; then
+	      rmfiles="$rmfiles $objdir/lt-${noexename}.c"
+	    fi
+	  fi
+	fi
+	;;
+      esac
+      $show "$rm $rmfiles"
+      $run $rm $rmfiles || exit_status=1
+    done
+    objdir="$origobjdir"
+
+    # Try to remove the ${objdir}s in the directories where we deleted files
+    for dir in $rmdirs; do
+      if test -d "$dir"; then
+	$show "rmdir $dir"
+	$run rmdir $dir >/dev/null 2>&1
+      fi
+    done
+
+    exit $exit_status
+    ;;
+
+  "")
+    $echo "$modename: you must specify a MODE" 1>&2
+    $echo "$generic_help" 1>&2
+    exit $EXIT_FAILURE
+    ;;
+  esac
+
+  if test -z "$exec_cmd"; then
+    $echo "$modename: invalid operation mode \`$mode'" 1>&2
+    $echo "$generic_help" 1>&2
+    exit $EXIT_FAILURE
+  fi
+fi # test -z "$show_help"
+
+if test -n "$exec_cmd"; then
+  eval exec $exec_cmd
+  exit $EXIT_FAILURE
+fi
+
+# We need to display help for each of the modes.
+case $mode in
+"") $echo \
+"Usage: $modename [OPTION]... [MODE-ARG]...
+
+Provide generalized library-building support services.
+
+    --config          show all configuration variables
+    --debug           enable verbose shell tracing
+-n, --dry-run         display commands without modifying any files
+    --features        display basic configuration information and exit
+    --finish          same as \`--mode=finish'
+    --help            display this help message and exit
+    --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
+    --quiet           same as \`--silent'
+    --silent          don't print informational messages
+    --tag=TAG         use configuration variables from tag TAG
+    --version         print version information
+
+MODE must be one of the following:
+
+      clean           remove files from the build directory
+      compile         compile a source file into a libtool object
+      execute         automatically set library path, then run a program
+      finish          complete the installation of libtool libraries
+      install         install libraries or executables
+      link            create a library or an executable
+      uninstall       remove libraries from an installed directory
+
+MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
+a more detailed description of MODE.
+
+Report bugs to <bug-libtool@gnu.org>."
+  exit $EXIT_SUCCESS
+  ;;
+
+clean)
+  $echo \
+"Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
+
+Remove files from the build directory.
+
+RM is the name of the program to use to delete files associated with each FILE
+(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
+to RM.
+
+If FILE is a libtool library, object or program, all the files associated
+with it are deleted. Otherwise, only FILE itself is deleted using RM."
+  ;;
+
+compile)
+  $echo \
+"Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
+
+Compile a source file into a libtool library object.
+
+This mode accepts the following additional options:
+
+  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
+  -prefer-pic       try to building PIC objects only
+  -prefer-non-pic   try to building non-PIC objects only
+  -static           always build a \`.o' file suitable for static linking
+
+COMPILE-COMMAND is a command to be used in creating a \`standard' object file
+from the given SOURCEFILE.
+
+The output file name is determined by removing the directory component from
+SOURCEFILE, then substituting the C source code suffix \`.c' with the
+library object suffix, \`.lo'."
+  ;;
+
+execute)
+  $echo \
+"Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
+
+Automatically set library path, then run a program.
+
+This mode accepts the following additional options:
+
+  -dlopen FILE      add the directory containing FILE to the library path
+
+This mode sets the library path environment variable according to \`-dlopen'
+flags.
+
+If any of the ARGS are libtool executable wrappers, then they are translated
+into their corresponding uninstalled binary, and any of their required library
+directories are added to the library path.
+
+Then, COMMAND is executed, with ARGS as arguments."
+  ;;
+
+finish)
+  $echo \
+"Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
+
+Complete the installation of libtool libraries.
+
+Each LIBDIR is a directory that contains libtool libraries.
+
+The commands that this mode executes may require superuser privileges.  Use
+the \`--dry-run' option if you just want to see what would be executed."
+  ;;
+
+install)
+  $echo \
+"Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
+
+Install executables or libraries.
+
+INSTALL-COMMAND is the installation command.  The first component should be
+either the \`install' or \`cp' program.
+
+The rest of the components are interpreted as arguments to that command (only
+BSD-compatible install options are recognized)."
+  ;;
+
+link)
+  $echo \
+"Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
+
+Link object files or libraries together to form another library, or to
+create an executable program.
+
+LINK-COMMAND is a command using the C compiler that you would use to create
+a program from several object files.
+
+The following components of LINK-COMMAND are treated specially:
+
+  -all-static       do not do any dynamic linking at all
+  -avoid-version    do not add a version suffix if possible
+  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
+  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
+  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
+  -export-symbols SYMFILE
+		    try to export only the symbols listed in SYMFILE
+  -export-symbols-regex REGEX
+		    try to export only the symbols matching REGEX
+  -LLIBDIR          search LIBDIR for required installed libraries
+  -lNAME            OUTPUT-FILE requires the installed library libNAME
+  -module           build a library that can dlopened
+  -no-fast-install  disable the fast-install mode
+  -no-install       link a not-installable executable
+  -no-undefined     declare that a library does not refer to external symbols
+  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
+  -objectlist FILE  Use a list of object files found in FILE to specify objects
+  -precious-files-regex REGEX
+                    don't remove output files matching REGEX
+  -release RELEASE  specify package release information
+  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
+  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
+  -static           do not do any dynamic linking of libtool libraries
+  -version-info CURRENT[:REVISION[:AGE]]
+		    specify library version info [each variable defaults to 0]
+
+All other options (arguments beginning with \`-') are ignored.
+
+Every other argument is treated as a filename.  Files ending in \`.la' are
+treated as uninstalled libtool libraries, other files are standard or library
+object files.
+
+If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
+only library objects (\`.lo' files) may be specified, and \`-rpath' is
+required, except when creating a convenience library.
+
+If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
+using \`ar' and \`ranlib', or on Windows using \`lib'.
+
+If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
+is created, otherwise an executable program is created."
+  ;;
+
+uninstall)
+  $echo \
+"Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
+
+Remove libraries from an installation directory.
+
+RM is the name of the program to use to delete files associated with each FILE
+(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
+to RM.
+
+If FILE is a libtool library, all the files associated with it are deleted.
+Otherwise, only FILE itself is deleted using RM."
+  ;;
+
+*)
+  $echo "$modename: invalid operation mode \`$mode'" 1>&2
+  $echo "$help" 1>&2
+  exit $EXIT_FAILURE
+  ;;
+esac
+
+$echo
+$echo "Try \`$modename --help' for more information about other modes."
+
+exit $?
+
+# The TAGs below are defined such that we never get into a situation
+# in which we disable both kinds of libraries.  Given conflicting
+# choices, we go for a static library, that is the most portable,
+# since we can't tell whether shared libraries were disabled because
+# the user asked for that or because the platform doesn't support
+# them.  This is particularly important on AIX, because we don't
+# support having both static and shared libraries enabled at the same
+# time on that platform, so we default to a shared-only configuration.
+# If a disable-shared tag is given, we'll fallback to a static-only
+# configuration.  But we'll never go from static-only to shared-only.
+
+# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
+disable_libs=shared
+# ### END LIBTOOL TAG CONFIG: disable-shared
+
+# ### BEGIN LIBTOOL TAG CONFIG: disable-static
+disable_libs=static
+# ### END LIBTOOL TAG CONFIG: disable-static
+
+# Local Variables:
+# mode:shell-script
+# sh-indentation:2
+# End:
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/m4/ac_have_attribute.m4 b/sdch/open_vcdiff/depot/opensource/open-vcdiff/m4/ac_have_attribute.m4
new file mode 100644
index 0000000..0efdb3ce
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/m4/ac_have_attribute.m4
@@ -0,0 +1,16 @@
+AC_DEFUN([AX_C___ATTRIBUTE__], [

+  AC_MSG_CHECKING(for __attribute__)

+  AC_CACHE_VAL(ac_cv___attribute__, [

+    AC_TRY_COMPILE(

+      [#include <stdlib.h>

+       static void foo(void) __attribute__ ((unused));

+       void foo(void) { exit(1); }],

+      [],

+      ac_cv___attribute__=yes,

+      ac_cv___attribute__=no

+    )])

+  if test "$ac_cv___attribute__" = "yes"; then

+    AC_DEFINE(HAVE___ATTRIBUTE__, 1, [define if your compiler has __attribute__])

+  fi

+  AC_MSG_RESULT($ac_cv___attribute__)

+])

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/m4/acx_pthread.m4 b/sdch/open_vcdiff/depot/opensource/open-vcdiff/m4/acx_pthread.m4
new file mode 100644
index 0000000..87e0cb0
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/m4/acx_pthread.m4
@@ -0,0 +1,363 @@
+# This was retrieved from

+#    http://svn.0pointer.de/viewvc/trunk/common/acx_pthread.m4?revision=1277&root=avahi

+# See also (perhaps for new versions?)

+#    http://svn.0pointer.de/viewvc/trunk/common/acx_pthread.m4?root=avahi

+#

+# We've rewritten the inconsistency check code (from avahi), to work

+# more broadly.  In particular, it no longer assumes ld accepts -zdefs.

+# This caused a restructing of the code, but the functionality has only

+# changed a little.

+

+dnl @synopsis ACX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])

+dnl

+dnl @summary figure out how to build C programs using POSIX threads

+dnl

+dnl This macro figures out how to build C programs using POSIX threads.

+dnl It sets the PTHREAD_LIBS output variable to the threads library and

+dnl linker flags, and the PTHREAD_CFLAGS output variable to any special

+dnl C compiler flags that are needed. (The user can also force certain

+dnl compiler flags/libs to be tested by setting these environment

+dnl variables.)

+dnl

+dnl Also sets PTHREAD_CC to any special C compiler that is needed for

+dnl multi-threaded programs (defaults to the value of CC otherwise).

+dnl (This is necessary on AIX to use the special cc_r compiler alias.)

+dnl

+dnl NOTE: You are assumed to not only compile your program with these

+dnl flags, but also link it with them as well. e.g. you should link

+dnl with $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS

+dnl $LIBS

+dnl

+dnl If you are only building threads programs, you may wish to use

+dnl these variables in your default LIBS, CFLAGS, and CC:

+dnl

+dnl        LIBS="$PTHREAD_LIBS $LIBS"

+dnl        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

+dnl        CC="$PTHREAD_CC"

+dnl

+dnl In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute

+dnl constant has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to

+dnl that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX).

+dnl

+dnl ACTION-IF-FOUND is a list of shell commands to run if a threads

+dnl library is found, and ACTION-IF-NOT-FOUND is a list of commands to

+dnl run it if it is not found. If ACTION-IF-FOUND is not specified, the

+dnl default action will define HAVE_PTHREAD.

+dnl

+dnl Please let the authors know if this macro fails on any platform, or

+dnl if you have any other suggestions or comments. This macro was based

+dnl on work by SGJ on autoconf scripts for FFTW (www.fftw.org) (with

+dnl help from M. Frigo), as well as ac_pthread and hb_pthread macros

+dnl posted by Alejandro Forero Cuervo to the autoconf macro repository.

+dnl We are also grateful for the helpful feedback of numerous users.

+dnl

+dnl @category InstalledPackages

+dnl @author Steven G. Johnson <stevenj@alum.mit.edu>

+dnl @version 2006-05-29

+dnl @license GPLWithACException

+dnl 

+dnl Checks for GCC shared/pthread inconsistency based on work by

+dnl Marcin Owsiany <marcin@owsiany.pl>

+

+

+AC_DEFUN([ACX_PTHREAD], [

+AC_REQUIRE([AC_CANONICAL_HOST])

+AC_LANG_SAVE

+AC_LANG_C

+acx_pthread_ok=no

+

+# We used to check for pthread.h first, but this fails if pthread.h

+# requires special compiler flags (e.g. on True64 or Sequent).

+# It gets checked for in the link test anyway.

+

+# First of all, check if the user has set any of the PTHREAD_LIBS,

+# etcetera environment variables, and if threads linking works using

+# them:

+if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then

+        save_CFLAGS="$CFLAGS"

+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

+        save_LIBS="$LIBS"

+        LIBS="$PTHREAD_LIBS $LIBS"

+        AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS])

+        AC_TRY_LINK_FUNC(pthread_join, acx_pthread_ok=yes)

+        AC_MSG_RESULT($acx_pthread_ok)

+        if test x"$acx_pthread_ok" = xno; then

+                PTHREAD_LIBS=""

+                PTHREAD_CFLAGS=""

+        fi

+        LIBS="$save_LIBS"

+        CFLAGS="$save_CFLAGS"

+fi

+

+# We must check for the threads library under a number of different

+# names; the ordering is very important because some systems

+# (e.g. DEC) have both -lpthread and -lpthreads, where one of the

+# libraries is broken (non-POSIX).

+

+# Create a list of thread flags to try.  Items starting with a "-" are

+# C compiler flags, and other items are library names, except for "none"

+# which indicates that we try without any flags at all, and "pthread-config"

+# which is a program returning the flags for the Pth emulation library.

+

+acx_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"

+

+# The ordering *is* (sometimes) important.  Some notes on the

+# individual items follow:

+

+# pthreads: AIX (must check this before -lpthread)

+# none: in case threads are in libc; should be tried before -Kthread and

+#       other compiler flags to prevent continual compiler warnings

+# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)

+# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)

+# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)

+# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)

+# -pthreads: Solaris/gcc

+# -mthreads: Mingw32/gcc, Lynx/gcc

+# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it

+#      doesn't hurt to check since this sometimes defines pthreads too;

+#      also defines -D_REENTRANT)

+#      ... -mt is also the pthreads flag for HP/aCC

+# pthread: Linux, etcetera

+# --thread-safe: KAI C++

+# pthread-config: use pthread-config program (for GNU Pth library)

+

+case "${host_cpu}-${host_os}" in

+        *solaris*)

+

+        # On Solaris (at least, for some versions), libc contains stubbed

+        # (non-functional) versions of the pthreads routines, so link-based

+        # tests will erroneously succeed.  (We need to link with -pthreads/-mt/

+        # -lpthread.)  (The stubs are missing pthread_cleanup_push, or rather

+        # a function called by this macro, so we could check for that, but

+        # who knows whether they'll stub that too in a future libc.)  So,

+        # we'll just look for -pthreads and -lpthread first:

+

+        acx_pthread_flags="-pthreads pthread -mt -pthread $acx_pthread_flags"

+        ;;

+esac

+

+if test x"$acx_pthread_ok" = xno; then

+for flag in $acx_pthread_flags; do

+

+        case $flag in

+                none)

+                AC_MSG_CHECKING([whether pthreads work without any flags])

+                ;;

+

+                -*)

+                AC_MSG_CHECKING([whether pthreads work with $flag])

+                PTHREAD_CFLAGS="$flag"

+                ;;

+

+		pthread-config)

+		AC_CHECK_PROG(acx_pthread_config, pthread-config, yes, no)

+		if test x"$acx_pthread_config" = xno; then continue; fi

+		PTHREAD_CFLAGS="`pthread-config --cflags`"

+		PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"

+		;;

+

+                *)

+                AC_MSG_CHECKING([for the pthreads library -l$flag])

+                PTHREAD_LIBS="-l$flag"

+                ;;

+        esac

+

+        save_LIBS="$LIBS"

+        save_CFLAGS="$CFLAGS"

+        LIBS="$PTHREAD_LIBS $LIBS"

+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

+

+        # Check for various functions.  We must include pthread.h,

+        # since some functions may be macros.  (On the Sequent, we

+        # need a special flag -Kthread to make this header compile.)

+        # We check for pthread_join because it is in -lpthread on IRIX

+        # while pthread_create is in libc.  We check for pthread_attr_init

+        # due to DEC craziness with -lpthreads.  We check for

+        # pthread_cleanup_push because it is one of the few pthread

+        # functions on Solaris that doesn't have a non-functional libc stub.

+        # We try pthread_create on general principles.

+        AC_TRY_LINK([#include <pthread.h>],

+                    [pthread_t th; pthread_join(th, 0);

+                     pthread_attr_init(0); pthread_cleanup_push(0, 0);

+                     pthread_create(0,0,0,0); pthread_cleanup_pop(0); ],

+                    [acx_pthread_ok=yes])

+

+        LIBS="$save_LIBS"

+        CFLAGS="$save_CFLAGS"

+

+        AC_MSG_RESULT($acx_pthread_ok)

+        if test "x$acx_pthread_ok" = xyes; then

+                break;

+        fi

+

+        PTHREAD_LIBS=""

+        PTHREAD_CFLAGS=""

+done

+fi

+

+# Various other checks:

+if test "x$acx_pthread_ok" = xyes; then

+        save_LIBS="$LIBS"

+        LIBS="$PTHREAD_LIBS $LIBS"

+        save_CFLAGS="$CFLAGS"

+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

+

+        # Detect AIX lossage: JOINABLE attribute is called UNDETACHED.

+	AC_MSG_CHECKING([for joinable pthread attribute])

+	attr_name=unknown

+	for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do

+	    AC_TRY_LINK([#include <pthread.h>], [int attr=$attr; return attr;],

+                        [attr_name=$attr; break])

+	done

+        AC_MSG_RESULT($attr_name)

+        if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then

+            AC_DEFINE_UNQUOTED(PTHREAD_CREATE_JOINABLE, $attr_name,

+                               [Define to necessary symbol if this constant

+                                uses a non-standard name on your system.])

+        fi

+

+        AC_MSG_CHECKING([if more special flags are required for pthreads])

+        flag=no

+        case "${host_cpu}-${host_os}" in

+            *-aix* | *-freebsd* | *-darwin*) flag="-D_THREAD_SAFE";;

+            *solaris* | *-osf* | *-hpux*) flag="-D_REENTRANT";;

+        esac

+        AC_MSG_RESULT(${flag})

+        if test "x$flag" != xno; then

+            PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"

+        fi

+

+        LIBS="$save_LIBS"

+        CFLAGS="$save_CFLAGS"

+        # More AIX lossage: must compile with xlc_r or cc_r

+	if test x"$GCC" != xyes; then

+          AC_CHECK_PROGS(PTHREAD_CC, xlc_r cc_r, ${CC})

+        else

+          PTHREAD_CC=$CC

+	fi

+

+	# The next part tries to detect GCC inconsistency with -shared on some

+	# architectures and systems. The problem is that in certain

+	# configurations, when -shared is specified, GCC "forgets" to

+	# internally use various flags which are still necessary.

+	

+	#

+	# Prepare the flags

+	#

+	save_CFLAGS="$CFLAGS"

+	save_LIBS="$LIBS"

+	save_CC="$CC"

+	

+	# Try with the flags determined by the earlier checks.

+	#

+	# -Wl,-z,defs forces link-time symbol resolution, so that the

+	# linking checks with -shared actually have any value

+	#

+	# FIXME: -fPIC is required for -shared on many architectures,

+	# so we specify it here, but the right way would probably be to

+	# properly detect whether it is actually required.

+	CFLAGS="-shared -fPIC -Wl,-z,defs $CFLAGS $PTHREAD_CFLAGS"

+	LIBS="$PTHREAD_LIBS $LIBS"

+	CC="$PTHREAD_CC"

+	

+	# In order not to create several levels of indentation, we test

+	# the value of "$done" until we find the cure or run out of ideas.

+	done="no"

+	

+	# First, make sure the CFLAGS we added are actually accepted by our

+	# compiler.  If not (and OS X's ld, for instance, does not accept -z),

+	# then we can't do this test.

+	if test x"$done" = xno; then

+	   AC_MSG_CHECKING([whether to check for GCC pthread/shared inconsistencies])

+	   AC_TRY_LINK(,, , [done=yes])

+	

+	   if test "x$done" = xyes ; then

+	      AC_MSG_RESULT([no])

+	   else

+	      AC_MSG_RESULT([yes])

+	   fi

+	fi

+	

+	if test x"$done" = xno; then

+	   AC_MSG_CHECKING([whether -pthread is sufficient with -shared])

+	   AC_TRY_LINK([#include <pthread.h>],

+	      [pthread_t th; pthread_join(th, 0);

+	      pthread_attr_init(0); pthread_cleanup_push(0, 0);

+	      pthread_create(0,0,0,0); pthread_cleanup_pop(0); ],

+	      [done=yes])

+	   

+	   if test "x$done" = xyes; then

+	      AC_MSG_RESULT([yes])

+	   else

+	      AC_MSG_RESULT([no])

+	   fi

+	fi

+	

+	#

+	# Linux gcc on some architectures such as mips/mipsel forgets

+	# about -lpthread

+	#

+	if test x"$done" = xno; then

+	   AC_MSG_CHECKING([whether -lpthread fixes that])

+	   LIBS="-lpthread $PTHREAD_LIBS $save_LIBS"

+	   AC_TRY_LINK([#include <pthread.h>],

+	      [pthread_t th; pthread_join(th, 0);

+	      pthread_attr_init(0); pthread_cleanup_push(0, 0);

+	      pthread_create(0,0,0,0); pthread_cleanup_pop(0); ],

+	      [done=yes])

+	

+	   if test "x$done" = xyes; then

+	      AC_MSG_RESULT([yes])

+	      PTHREAD_LIBS="-lpthread $PTHREAD_LIBS"

+	   else

+	      AC_MSG_RESULT([no])

+	   fi

+	fi

+	#

+	# FreeBSD 4.10 gcc forgets to use -lc_r instead of -lc

+	#

+	if test x"$done" = xno; then

+	   AC_MSG_CHECKING([whether -lc_r fixes that])

+	   LIBS="-lc_r $PTHREAD_LIBS $save_LIBS"

+	   AC_TRY_LINK([#include <pthread.h>],

+	       [pthread_t th; pthread_join(th, 0);

+	        pthread_attr_init(0); pthread_cleanup_push(0, 0);

+	        pthread_create(0,0,0,0); pthread_cleanup_pop(0); ],

+	       [done=yes])

+	

+	   if test "x$done" = xyes; then

+	      AC_MSG_RESULT([yes])

+	      PTHREAD_LIBS="-lc_r $PTHREAD_LIBS"

+	   else

+	      AC_MSG_RESULT([no])

+	   fi

+	fi

+	if test x"$done" = xno; then

+	   # OK, we have run out of ideas

+	   AC_MSG_WARN([Impossible to determine how to use pthreads with shared libraries])

+	

+	   # so it's not safe to assume that we may use pthreads

+	   acx_pthread_ok=no

+	fi

+	

+	CFLAGS="$save_CFLAGS"

+	LIBS="$save_LIBS"

+	CC="$save_CC"

+else

+        PTHREAD_CC="$CC"

+fi

+

+AC_SUBST(PTHREAD_LIBS)

+AC_SUBST(PTHREAD_CFLAGS)

+AC_SUBST(PTHREAD_CC)

+

+# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:

+if test x"$acx_pthread_ok" = xyes; then

+        ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1])

+        :

+else

+        acx_pthread_ok=no

+        $2

+fi

+AC_LANG_RESTORE

+])dnl ACX_PTHREAD

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/missing b/sdch/open_vcdiff/depot/opensource/open-vcdiff/missing
new file mode 100644
index 0000000..0e290c1
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/missing
@@ -0,0 +1,360 @@
+#! /bin/sh

+# Common stub for a few missing GNU programs while installing.

+

+scriptversion=2005-06-08.21

+

+# Copyright (C) 1996, 1997, 1999, 2000, 2002, 2003, 2004, 2005

+#   Free Software Foundation, Inc.

+# Originally by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.

+

+# This program is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published by

+# the Free Software Foundation; either version 2, or (at your option)

+# any later version.

+

+# This program is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+# GNU General Public License for more details.

+

+# You should have received a copy of the GNU General Public License

+# along with this program; if not, write to the Free Software

+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

+# 02110-1301, USA.

+

+# As a special exception to the GNU General Public License, if you

+# distribute this file as part of a program that contains a

+# configuration script generated by Autoconf, you may include it under

+# the same distribution terms that you use for the rest of that program.

+

+if test $# -eq 0; then

+  echo 1>&2 "Try \`$0 --help' for more information"

+  exit 1

+fi

+

+run=:

+

+# In the cases where this matters, `missing' is being run in the

+# srcdir already.

+if test -f configure.ac; then

+  configure_ac=configure.ac

+else

+  configure_ac=configure.in

+fi

+

+msg="missing on your system"

+

+case "$1" in

+--run)

+  # Try to run requested program, and just exit if it succeeds.

+  run=

+  shift

+  "$@" && exit 0

+  # Exit code 63 means version mismatch.  This often happens

+  # when the user try to use an ancient version of a tool on

+  # a file that requires a minimum version.  In this case we

+  # we should proceed has if the program had been absent, or

+  # if --run hadn't been passed.

+  if test $? = 63; then

+    run=:

+    msg="probably too old"

+  fi

+  ;;

+

+  -h|--h|--he|--hel|--help)

+    echo "\

+$0 [OPTION]... PROGRAM [ARGUMENT]...

+

+Handle \`PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an

+error status if there is no known handling for PROGRAM.

+

+Options:

+  -h, --help      display this help and exit

+  -v, --version   output version information and exit

+  --run           try to run the given command, and emulate it if it fails

+

+Supported PROGRAM values:

+  aclocal      touch file \`aclocal.m4'

+  autoconf     touch file \`configure'

+  autoheader   touch file \`config.h.in'

+  automake     touch all \`Makefile.in' files

+  bison        create \`y.tab.[ch]', if possible, from existing .[ch]

+  flex         create \`lex.yy.c', if possible, from existing .c

+  help2man     touch the output file

+  lex          create \`lex.yy.c', if possible, from existing .c

+  makeinfo     touch the output file

+  tar          try tar, gnutar, gtar, then tar without non-portable flags

+  yacc         create \`y.tab.[ch]', if possible, from existing .[ch]

+

+Send bug reports to <bug-automake@gnu.org>."

+    exit $?

+    ;;

+

+  -v|--v|--ve|--ver|--vers|--versi|--versio|--version)

+    echo "missing $scriptversion (GNU Automake)"

+    exit $?

+    ;;

+

+  -*)

+    echo 1>&2 "$0: Unknown \`$1' option"

+    echo 1>&2 "Try \`$0 --help' for more information"

+    exit 1

+    ;;

+

+esac

+

+# Now exit if we have it, but it failed.  Also exit now if we

+# don't have it and --version was passed (most likely to detect

+# the program).

+case "$1" in

+  lex|yacc)

+    # Not GNU programs, they don't have --version.

+    ;;

+

+  tar)

+    if test -n "$run"; then

+       echo 1>&2 "ERROR: \`tar' requires --run"

+       exit 1

+    elif test "x$2" = "x--version" || test "x$2" = "x--help"; then

+       exit 1

+    fi

+    ;;

+

+  *)

+    if test -z "$run" && ($1 --version) > /dev/null 2>&1; then

+       # We have it, but it failed.

+       exit 1

+    elif test "x$2" = "x--version" || test "x$2" = "x--help"; then

+       # Could not run --version or --help.  This is probably someone

+       # running `$TOOL --version' or `$TOOL --help' to check whether

+       # $TOOL exists and not knowing $TOOL uses missing.

+       exit 1

+    fi

+    ;;

+esac

+

+# If it does not exist, or fails to run (possibly an outdated version),

+# try to emulate it.

+case "$1" in

+  aclocal*)

+    echo 1>&2 "\

+WARNING: \`$1' is $msg.  You should only need it if

+         you modified \`acinclude.m4' or \`${configure_ac}'.  You might want

+         to install the \`Automake' and \`Perl' packages.  Grab them from

+         any GNU archive site."

+    touch aclocal.m4

+    ;;

+

+  autoconf)

+    echo 1>&2 "\

+WARNING: \`$1' is $msg.  You should only need it if

+         you modified \`${configure_ac}'.  You might want to install the

+         \`Autoconf' and \`GNU m4' packages.  Grab them from any GNU

+         archive site."

+    touch configure

+    ;;

+

+  autoheader)

+    echo 1>&2 "\

+WARNING: \`$1' is $msg.  You should only need it if

+         you modified \`acconfig.h' or \`${configure_ac}'.  You might want

+         to install the \`Autoconf' and \`GNU m4' packages.  Grab them

+         from any GNU archive site."

+    files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' ${configure_ac}`

+    test -z "$files" && files="config.h"

+    touch_files=

+    for f in $files; do

+      case "$f" in

+      *:*) touch_files="$touch_files "`echo "$f" |

+				       sed -e 's/^[^:]*://' -e 's/:.*//'`;;

+      *) touch_files="$touch_files $f.in";;

+      esac

+    done

+    touch $touch_files

+    ;;

+

+  automake*)

+    echo 1>&2 "\

+WARNING: \`$1' is $msg.  You should only need it if

+         you modified \`Makefile.am', \`acinclude.m4' or \`${configure_ac}'.

+         You might want to install the \`Automake' and \`Perl' packages.

+         Grab them from any GNU archive site."

+    find . -type f -name Makefile.am -print |

+	   sed 's/\.am$/.in/' |

+	   while read f; do touch "$f"; done

+    ;;

+

+  autom4te)

+    echo 1>&2 "\

+WARNING: \`$1' is needed, but is $msg.

+         You might have modified some files without having the

+         proper tools for further handling them.

+         You can get \`$1' as part of \`Autoconf' from any GNU

+         archive site."

+

+    file=`echo "$*" | sed -n 's/.*--output[ =]*\([^ ]*\).*/\1/p'`

+    test -z "$file" && file=`echo "$*" | sed -n 's/.*-o[ ]*\([^ ]*\).*/\1/p'`

+    if test -f "$file"; then

+	touch $file

+    else

+	test -z "$file" || exec >$file

+	echo "#! /bin/sh"

+	echo "# Created by GNU Automake missing as a replacement of"

+	echo "#  $ $@"

+	echo "exit 0"

+	chmod +x $file

+	exit 1

+    fi

+    ;;

+

+  bison|yacc)

+    echo 1>&2 "\

+WARNING: \`$1' $msg.  You should only need it if

+         you modified a \`.y' file.  You may need the \`Bison' package

+         in order for those modifications to take effect.  You can get

+         \`Bison' from any GNU archive site."

+    rm -f y.tab.c y.tab.h

+    if [ $# -ne 1 ]; then

+        eval LASTARG="\${$#}"

+	case "$LASTARG" in

+	*.y)

+	    SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'`

+	    if [ -f "$SRCFILE" ]; then

+	         cp "$SRCFILE" y.tab.c

+	    fi

+	    SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'`

+	    if [ -f "$SRCFILE" ]; then

+	         cp "$SRCFILE" y.tab.h

+	    fi

+	  ;;

+	esac

+    fi

+    if [ ! -f y.tab.h ]; then

+	echo >y.tab.h

+    fi

+    if [ ! -f y.tab.c ]; then

+	echo 'main() { return 0; }' >y.tab.c

+    fi

+    ;;

+

+  lex|flex)

+    echo 1>&2 "\

+WARNING: \`$1' is $msg.  You should only need it if

+         you modified a \`.l' file.  You may need the \`Flex' package

+         in order for those modifications to take effect.  You can get

+         \`Flex' from any GNU archive site."

+    rm -f lex.yy.c

+    if [ $# -ne 1 ]; then

+        eval LASTARG="\${$#}"

+	case "$LASTARG" in

+	*.l)

+	    SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'`

+	    if [ -f "$SRCFILE" ]; then

+	         cp "$SRCFILE" lex.yy.c

+	    fi

+	  ;;

+	esac

+    fi

+    if [ ! -f lex.yy.c ]; then

+	echo 'main() { return 0; }' >lex.yy.c

+    fi

+    ;;

+

+  help2man)

+    echo 1>&2 "\

+WARNING: \`$1' is $msg.  You should only need it if

+	 you modified a dependency of a manual page.  You may need the

+	 \`Help2man' package in order for those modifications to take

+	 effect.  You can get \`Help2man' from any GNU archive site."

+

+    file=`echo "$*" | sed -n 's/.*-o \([^ ]*\).*/\1/p'`

+    if test -z "$file"; then

+	file=`echo "$*" | sed -n 's/.*--output=\([^ ]*\).*/\1/p'`

+    fi

+    if [ -f "$file" ]; then

+	touch $file

+    else

+	test -z "$file" || exec >$file

+	echo ".ab help2man is required to generate this page"

+	exit 1

+    fi

+    ;;

+

+  makeinfo)

+    echo 1>&2 "\

+WARNING: \`$1' is $msg.  You should only need it if

+         you modified a \`.texi' or \`.texinfo' file, or any other file

+         indirectly affecting the aspect of the manual.  The spurious

+         call might also be the consequence of using a buggy \`make' (AIX,

+         DU, IRIX).  You might want to install the \`Texinfo' package or

+         the \`GNU make' package.  Grab either from any GNU archive site."

+    # The file to touch is that specified with -o ...

+    file=`echo "$*" | sed -n 's/.*-o \([^ ]*\).*/\1/p'`

+    if test -z "$file"; then

+      # ... or it is the one specified with @setfilename ...

+      infile=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'`

+      file=`sed -n '/^@setfilename/ { s/.* \([^ ]*\) *$/\1/; p; q; }' $infile`

+      # ... or it is derived from the source name (dir/f.texi becomes f.info)

+      test -z "$file" && file=`echo "$infile" | sed 's,.*/,,;s,.[^.]*$,,'`.info

+    fi

+    # If the file does not exist, the user really needs makeinfo;

+    # let's fail without touching anything.

+    test -f $file || exit 1

+    touch $file

+    ;;

+

+  tar)

+    shift

+

+    # We have already tried tar in the generic part.

+    # Look for gnutar/gtar before invocation to avoid ugly error

+    # messages.

+    if (gnutar --version > /dev/null 2>&1); then

+       gnutar "$@" && exit 0

+    fi

+    if (gtar --version > /dev/null 2>&1); then

+       gtar "$@" && exit 0

+    fi

+    firstarg="$1"

+    if shift; then

+	case "$firstarg" in

+	*o*)

+	    firstarg=`echo "$firstarg" | sed s/o//`

+	    tar "$firstarg" "$@" && exit 0

+	    ;;

+	esac

+	case "$firstarg" in

+	*h*)

+	    firstarg=`echo "$firstarg" | sed s/h//`

+	    tar "$firstarg" "$@" && exit 0

+	    ;;

+	esac

+    fi

+

+    echo 1>&2 "\

+WARNING: I can't seem to be able to run \`tar' with the given arguments.

+         You may want to install GNU tar or Free paxutils, or check the

+         command line arguments."

+    exit 1

+    ;;

+

+  *)

+    echo 1>&2 "\

+WARNING: \`$1' is needed, and is $msg.

+         You might have modified some files without having the

+         proper tools for further handling them.  Check the \`README' file,

+         it often tells you about the needed prerequisites for installing

+         this package.  You may also peek at any GNU archive site, in case

+         some other package would contain this missing \`$1' program."

+    exit 1

+    ;;

+esac

+

+exit 0

+

+# Local variables:

+# eval: (add-hook 'write-file-hooks 'time-stamp)

+# time-stamp-start: "scriptversion="

+# time-stamp-format: "%:y-%02m-%02d.%02H"

+# time-stamp-end: "$"

+# End:

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/mkinstalldirs b/sdch/open_vcdiff/depot/opensource/open-vcdiff/mkinstalldirs
new file mode 100644
index 0000000..8ef092d
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/mkinstalldirs
@@ -0,0 +1,158 @@
+#! /bin/sh

+# mkinstalldirs --- make directory hierarchy

+

+scriptversion=2005-06-29.22

+

+# Original author: Noah Friedman <friedman@prep.ai.mit.edu>

+# Created: 1993-05-16

+# Public domain.

+#

+# This file is maintained in Automake, please report

+# bugs to <bug-automake@gnu.org> or send patches to

+# <automake-patches@gnu.org>.

+

+errstatus=0

+dirmode=

+

+usage="\

+Usage: mkinstalldirs [-h] [--help] [--version] [-m MODE] DIR ...

+

+Create each directory DIR (with mode MODE, if specified), including all

+leading file name components.

+

+Report bugs to <bug-automake@gnu.org>."

+

+# process command line arguments

+while test $# -gt 0 ; do

+  case $1 in

+    -h | --help | --h*)         # -h for help

+      echo "$usage"

+      exit $?

+      ;;

+    -m)                         # -m PERM arg

+      shift

+      test $# -eq 0 && { echo "$usage" 1>&2; exit 1; }

+      dirmode=$1

+      shift

+      ;;

+    --version)

+      echo "$0 $scriptversion"

+      exit $?

+      ;;

+    --)                         # stop option processing

+      shift

+      break

+      ;;

+    -*)                         # unknown option

+      echo "$usage" 1>&2

+      exit 1

+      ;;

+    *)                          # first non-opt arg

+      break

+      ;;

+  esac

+done

+

+for file

+do

+  if test -d "$file"; then

+    shift

+  else

+    break

+  fi

+done

+

+case $# in

+  0) exit 0 ;;

+esac

+

+# Solaris 8's mkdir -p isn't thread-safe.  If you mkdir -p a/b and

+# mkdir -p a/c at the same time, both will detect that a is missing,

+# one will create a, then the other will try to create a and die with

+# a "File exists" error.  This is a problem when calling mkinstalldirs

+# from a parallel make.  We use --version in the probe to restrict

+# ourselves to GNU mkdir, which is thread-safe.

+case $dirmode in

+  '')

+    if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then

+      echo "mkdir -p -- $*"

+      exec mkdir -p -- "$@"

+    else

+      # On NextStep and OpenStep, the `mkdir' command does not

+      # recognize any option.  It will interpret all options as

+      # directories to create, and then abort because `.' already

+      # exists.

+      test -d ./-p && rmdir ./-p

+      test -d ./--version && rmdir ./--version

+    fi

+    ;;

+  *)

+    if mkdir -m "$dirmode" -p --version . >/dev/null 2>&1 &&

+       test ! -d ./--version; then

+      echo "mkdir -m $dirmode -p -- $*"

+      exec mkdir -m "$dirmode" -p -- "$@"

+    else

+      # Clean up after NextStep and OpenStep mkdir.

+      for d in ./-m ./-p ./--version "./$dirmode";

+      do

+        test -d $d && rmdir $d

+      done

+    fi

+    ;;

+esac

+

+for file

+do

+  case $file in

+    /*) pathcomp=/ ;;

+    *)  pathcomp= ;;

+  esac

+  oIFS=$IFS

+  IFS=/

+  set fnord $file

+  shift

+  IFS=$oIFS

+

+  for d

+  do

+    test "x$d" = x && continue

+

+    pathcomp=$pathcomp$d

+    case $pathcomp in

+      -*) pathcomp=./$pathcomp ;;

+    esac

+

+    if test ! -d "$pathcomp"; then

+      echo "mkdir $pathcomp"

+

+      mkdir "$pathcomp" || lasterr=$?

+

+      if test ! -d "$pathcomp"; then

+	errstatus=$lasterr

+      else

+	if test ! -z "$dirmode"; then

+	  echo "chmod $dirmode $pathcomp"

+	  lasterr=

+	  chmod "$dirmode" "$pathcomp" || lasterr=$?

+

+	  if test ! -z "$lasterr"; then

+	    errstatus=$lasterr

+	  fi

+	fi

+      fi

+    fi

+

+    pathcomp=$pathcomp/

+  done

+done

+

+exit $errstatus

+

+# Local Variables:

+# mode: shell-script

+# sh-indentation: 2

+# eval: (add-hook 'write-file-hooks 'time-stamp)

+# time-stamp-start: "scriptversion="

+# time-stamp-format: "%:y-%02m-%02d.%02H"

+# time-stamp-end: "$"

+# End:

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb.sh b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb.sh
new file mode 100755
index 0000000..ced98fa
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb.sh
@@ -0,0 +1,70 @@
+#!/bin/bash -e
+
+# This takes one commandline argument, the name of the package.  If no
+# name is given, then we'll end up just using the name associated with
+# an arbitrary .tar.gz file in the rootdir.  That's fine: there's probably
+# only one.
+#
+# Run this from the 'packages' directory, just under rootdir
+
+## Set LIB to lib if exporting a library, empty-string else
+LIB=
+#LIB=lib
+
+PACKAGE="$1"
+
+# We can only build Debian packages, if the Debian build tools are installed
+if [ \! -x /usr/bin/debuild ]; then
+  echo "Cannot find /usr/bin/debuild. Not building Debian packages." 1>&2
+  exit 0
+fi
+
+# Double-check we're in the packages directory, just under rootdir
+if [ \! -r ../Makefile -a \! -r ../INSTALL ]; then
+  echo "Must run $0 in the 'packages' directory, under the root directory." 1>&2
+  echo "Also, you must run \"make dist\" before running this script." 1>&2
+  exit 0
+fi
+
+# Find the top directory for this package
+topdir="${PWD%/*}"
+
+# Find the tar archive built by "make dist"
+archive="$(basename "$(ls -1 ${topdir}/$PACKAGE*.tar.gz | tail -n 1)" .tar.gz)"
+if [ -z "${archive}" ]; then
+  echo "Cannot find ../$PACKAGE*.tar.gz. Run \"make dist\" first." 1>&2
+  exit 0
+fi
+
+# Create a pristine directory for building the Debian package files
+trap 'rm -rf '`pwd`/tmp'; exit $?' EXIT SIGHUP SIGINT SIGTERM
+
+rm -rf tmp
+mkdir -p tmp
+cd tmp
+
+# Debian has very specific requirements about the naming of build
+# directories, and tar archives. It also wants to write all generated
+# packages to the parent of the source directory. We accommodate these
+# requirements by building directly from the tar file.
+ln -s "${topdir}/${archive}.tar.gz" "${LIB}${archive}.orig.tar.gz"
+tar zfx "${LIB}${archive}.orig.tar.gz"
+[ -n "${LIB}" ] && mv "${archive}" "${LIB}${archive}"
+cd "${LIB}${archive}"
+# This is one of those 'specific requirements': where the deb control files live
+ln -s "packages/deb" "debian"
+
+# Now, we can call Debian's standard build tool
+debuild -uc -us
+cd ../..                            # get back to the original top-level dir
+
+# We'll put the result in a subdirectory that's named after the OS version
+# we've made this .deb file for.
+destdir="debian-$(cat /etc/debian_version 2>/dev/null || echo UNKNOWN)"
+
+rm -rf "$destdir"
+mkdir -p "$destdir"
+mv $(find tmp -mindepth 1 -maxdepth 1 -type f) "$destdir"
+
+echo
+echo "The Debian package files are located in $PWD/$destdir"
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/README b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/README
new file mode 100644
index 0000000..57becfd
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/README
@@ -0,0 +1,7 @@
+The list of files here isn't complete.  For a step-by-step guide on
+how to set this package up correctly, check out
+    http://www.debian.org/doc/maint-guide/
+
+Most of the files that are in this directory are boilerplate.
+However, you may need to change the list of binary-arch dependencies
+in 'rules'.
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/changelog b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/changelog
new file mode 100644
index 0000000..3ca651e
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/changelog
@@ -0,0 +1,5 @@
+open-vcdiff (0.1-1) unstable; urgency=low

+

+  * Initial release.

+

+ -- Google Inc. <opensource@google.com>  Mon, 16 Jun 2008 15:15:51 -0700

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/compat b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/compat
new file mode 100644
index 0000000..e0e1028
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/compat
@@ -0,0 +1 @@
+4

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/control b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/control
new file mode 100644
index 0000000..0192346
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/control
@@ -0,0 +1,22 @@
+Source: open-vcdiff

+Priority: optional

+Maintainer: Google Inc. <opensource@google.com>

+Build-Depends: debhelper (>= 4.0.0), binutils

+Standards-Version: 3.6.1

+

+Package: libopen-vcdiff-dev

+Section: libdevel

+Architecture: any

+Depends: libopen-vcdiff (= ${Source-Version})

+Description: A library that provides an encoder and decoder for the VCDIFF

+(RFC 3284) format.  Please see http://www.ietf.org/rfc/rfc3284.txt .

+The devel package contains static and debug libraries and header files

+for developing applications that use the open-vcdiff package.

+

+Package: libopen-vcdiff0

+Section: libs

+Architecture: any

+Depends: ${shlibs:Depends}

+Description: A library that provides an encoder and decoder for the VCDIFF

+(RFC 3284) format.  Please see http://www.ietf.org/rfc/rfc3284.txt .

+

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/copyright b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/copyright
new file mode 100644
index 0000000..43b31f6
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/copyright
@@ -0,0 +1,20 @@
+This package was debianized by Google Inc. <opensource@google.com> on

+16 June 2008.

+

+It was downloaded from http://code.google.com/p/open-vcdiff

+

+Upstream Author: opensource@google.com

+

+Copyright 2008 Google Inc.

+

+Licensed under the Apache License, Version 2.0 (the "License");

+you may not use this file except in compliance with the License.

+You may obtain a copy of the License at

+

+     http://www.apache.org/licenses/LICENSE-2.0

+

+Unless required by applicable law or agreed to in writing, software

+distributed under the License is distributed on an "AS IS" BASIS,

+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+See the License for the specific language governing permissions and

+limitations under the License.

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/docs b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/docs
new file mode 100644
index 0000000..b95292b
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/docs
@@ -0,0 +1,6 @@
+AUTHORS

+COPYING

+ChangeLog

+INSTALL

+NEWS

+README

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/rules b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/rules
new file mode 100644
index 0000000..15d2c5f
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/deb/rules
@@ -0,0 +1,117 @@
+#!/usr/bin/make -f

+# -*- makefile -*-

+# Sample debian/rules that uses debhelper.

+# This file was originally written by Joey Hess and Craig Small.

+# As a special exception, when this file is copied by dh-make into a

+# dh-make output file, you may use that output file without restriction.

+# This special exception was added by Craig Small in version 0.37 of dh-make.

+

+# Uncomment this to turn on verbose mode.

+#export DH_VERBOSE=1

+

+

+# These are used for cross-compiling and for saving the configure script

+# from having to guess our platform (since we know it already)

+DEB_HOST_GNU_TYPE   ?= $(shell dpkg-architecture -qDEB_HOST_GNU_TYPE)

+DEB_BUILD_GNU_TYPE  ?= $(shell dpkg-architecture -qDEB_BUILD_GNU_TYPE)

+

+

+CFLAGS = -Wall -g

+

+ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS)))

+	CFLAGS += -O0

+else

+	CFLAGS += -O2

+endif

+ifeq (,$(findstring nostrip,$(DEB_BUILD_OPTIONS)))

+	INSTALL_PROGRAM += -s

+endif

+

+# shared library versions, option 1

+#version=2.0.5

+#major=2

+# option 2, assuming the library is created as src/.libs/libfoo.so.2.0.5 or so

+version=`ls src/.libs/lib*.so.* | \

+ awk '{if (match($$0,/[0-9]+\.[0-9]+\.[0-9]+$$/)) print substr($$0,RSTART)}'`

+major=`ls src/.libs/lib*.so.* | \

+ awk '{if (match($$0,/\.so\.[0-9]+$$/)) print substr($$0,RSTART+4)}'`

+

+config.status: configure

+	dh_testdir

+	# Add here commands to configure the package.

+	CFLAGS="$(CFLAGS)" ./configure --host=$(DEB_HOST_GNU_TYPE) --build=$(DEB_BUILD_GNU_TYPE) --prefix=/usr --mandir=\$${prefix}/share/man --infodir=\$${prefix}/share/info

+

+

+build: build-stamp

+build-stamp:  config.status

+	dh_testdir

+

+	# Add here commands to compile the package.

+	$(MAKE)

+

+	touch build-stamp

+

+clean:

+	dh_testdir

+	dh_testroot

+	rm -f build-stamp 

+

+	# Add here commands to clean up after the build process.

+	-$(MAKE) distclean

+ifneq "$(wildcard /usr/share/misc/config.sub)" ""

+	cp -f /usr/share/misc/config.sub config.sub

+endif

+ifneq "$(wildcard /usr/share/misc/config.guess)" ""

+	cp -f /usr/share/misc/config.guess config.guess

+endif

+

+

+	dh_clean 

+

+install: build

+	dh_testdir

+	dh_testroot

+	dh_clean -k 

+	dh_installdirs

+

+	# Add here commands to install the package into debian/tmp

+	$(MAKE) install DESTDIR=$(CURDIR)/debian/tmp

+

+

+# Build architecture-independent files here.

+binary-indep: build install

+# We have nothing to do by default.

+

+# Build architecture-dependent files here.

+binary-arch: build install

+	dh_testdir

+	dh_testroot

+	dh_installchangelogs ChangeLog

+	dh_installdocs

+	dh_installexamples

+	dh_install --sourcedir=debian/tmp

+#	dh_installmenu

+#	dh_installdebconf	

+#	dh_installlogrotate

+#	dh_installemacsen

+#	dh_installpam

+#	dh_installmime

+#	dh_installinit

+#	dh_installcron

+#	dh_installinfo

+	dh_installman

+	dh_link

+	dh_strip

+	dh_compress

+	dh_fixperms

+#	dh_perl

+#	dh_python

+	dh_makeshlibs

+	dh_installdeb

+	dh_shlibdeps

+	dh_gencontrol

+	dh_md5sums

+	dh_builddeb

+

+binary: binary-indep binary-arch

+.PHONY: build clean binary-indep binary-arch binary install 

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/rpm.sh b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/rpm.sh
new file mode 100755
index 0000000..5395dc0
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/rpm.sh
@@ -0,0 +1,75 @@
+#!/bin/sh -e
+
+# Run this from the 'packages' directory, just under rootdir
+
+# We can only build rpm packages, if the rpm build tools are installed
+if [ \! -x /usr/bin/rpmbuild ]
+then
+  echo "Cannot find /usr/bin/rpmbuild. Not building an rpm." 1>&2
+  exit 0
+fi
+
+# Check the commandline flags
+PACKAGE="$1"
+VERSION="$2"
+fullname="${PACKAGE}-${VERSION}"
+archive=../$fullname.tar.gz
+
+if [ -z "$1" -o -z "$2" ]
+then
+  echo "Usage: $0 <package name> <package version>" 1>&2
+  exit 0
+fi
+
+# Double-check we're in the packages directory, just under rootdir
+if [ \! -r ../Makefile -a \! -r ../INSTALL ]
+then
+  echo "Must run $0 in the 'packages' directory, under the root directory." 1>&2
+  echo "Also, you must run \"make dist\" before running this script." 1>&2
+  exit 0
+fi
+
+if [ \! -r "$archive" ]
+then
+  echo "Cannot find $archive. Run \"make dist\" first." 1>&2
+  exit 0
+fi
+
+# Create the directory where the input lives, and where the output should live
+RPM_SOURCE_DIR="/tmp/rpmsource-$fullname"
+RPM_BUILD_DIR="/tmp/rpmbuild-$fullname"
+
+trap 'rm -rf $RPM_SOURCE_DIR $RPM_BUILD_DIR; exit $?' EXIT SIGHUP SIGINT SIGTERM
+
+rm -rf "$RPM_SOURCE_DIR" "$RPM_BUILD_DIR"
+mkdir "$RPM_SOURCE_DIR"
+mkdir "$RPM_BUILD_DIR"
+
+cp "$archive" "$RPM_SOURCE_DIR"
+
+rpmbuild -bb rpm/rpm.spec \
+  --define "NAME $PACKAGE" \
+  --define "VERSION $VERSION" \
+  --define "_sourcedir $RPM_SOURCE_DIR" \
+  --define "_builddir $RPM_BUILD_DIR" \
+  --define "_rpmdir $RPM_SOURCE_DIR"
+
+# We put the output in a directory based on what system we've built for
+destdir=rpm-unknown
+if [ -r /etc/issue ]
+then
+   grep "Red Hat.*release 7" /etc/issue >/dev/null 2>&1 && destdir=rh7
+   grep "Red Hat.*release 8" /etc/issue >/dev/null 2>&1 && destdir=rh8
+   grep "Red Hat.*release 9" /etc/issue >/dev/null 2>&1 && destdir=rh9
+   if grep Fedora /etc/issue >/dev/null; then 
+	destdir=fc`grep Fedora /etc/issue | cut -d' ' -f 4`;
+   fi
+fi
+
+rm -rf "$destdir"
+mkdir -p "$destdir"
+# We want to get not only the main package but devel etc, hence the middle *
+mv "$RPM_SOURCE_DIR"/*/"${PACKAGE}"-*"${VERSION}"*.rpm "$destdir"
+
+echo
+echo "The rpm package file(s) are located in $PWD/$destdir"
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/rpm/rpm.spec b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/rpm/rpm.spec
new file mode 100644
index 0000000..9d71daf
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/packages/rpm/rpm.spec
@@ -0,0 +1,82 @@
+%define	RELEASE	1

+%define rel     %{?CUSTOM_RELEASE} %{!?CUSTOM_RELEASE:%RELEASE}

+%define	prefix	/usr

+

+Name: %NAME

+Summary: An encoder/decoder for the VCDIFF (RFC 3284) format

+Version: %VERSION

+Release: %rel

+Group: Development/Libraries

+URL: http://code.google.com/p/open-vcdiff

+License: Apache 2.0

+Vendor: Google

+Packager: Google Inc. <opensource@google.com>

+Source: http://%{NAME}.googlecode.com/files/%{NAME}-%{VERSION}.tar.gz

+Distribution: Redhat 7 and above.

+Buildroot: %{_tmppath}/%{name}-root

+Prefix: %prefix

+

+%description

+A library that provides an encoder and decoder for the VCDIFF

+(RFC 3284) format.  Please see http://www.ietf.org/rfc/rfc3284.txt .

+

+%package devel

+Summary: An encoder/decoder for the VCDIFF (RFC 3284) format

+Group: Development/Libraries

+Requires: %{NAME} = %{VERSION}

+

+%description devel

+The %name-devel package contains static and debug libraries and header files

+for developing applications that use the %name package.

+

+%changelog

+    * Mon Jun 16 2008 <opensource@google.com>

+    - First draft

+

+%prep

+%setup

+

+%build

+./configure

+make prefix=%prefix

+

+%install

+rm -rf $RPM_BUILD_ROOT

+make prefix=$RPM_BUILD_ROOT%{prefix} install

+

+%clean

+rm -rf $RPM_BUILD_ROOT

+

+%files

+%defattr(-,root,root)

+

+## Mark all installed files within /usr/share/doc/{package name} as

+## documentation.  This depends on the following two lines appearing in

+## Makefile.am:

+##     docdir = $(prefix)/share/doc/$(PACKAGE)-$(VERSION)

+##     dist_doc_DATA = AUTHORS COPYING ChangeLog INSTALL NEWS README

+%docdir %{prefix}/share/doc/%{NAME}-%{VERSION}

+%{prefix}/share/doc/%{NAME}-%{VERSION}/*

+

+%{prefix}/bin/vcdiff

+%{prefix}/lib/libvcdcom.so.0

+%{prefix}/lib/libvcdcom.so.0.0.0

+%{prefix}/lib/libvcdenc.so.0

+%{prefix}/lib/libvcdenc.so.0.0.0

+%{prefix}/lib/libvcddec.so.0

+%{prefix}/lib/libvcddec.so.0.0.0

+

+%files devel

+%defattr(-,root,root)

+

+%{prefix}/include/google

+%{prefix}/lib/libvcdcom.a

+%{prefix}/lib/libvcdcom.la

+%{prefix}/lib/libvcdcom.so

+%{prefix}/lib/libvcdenc.a

+%{prefix}/lib/libvcdenc.la

+%{prefix}/lib/libvcdenc.so

+%{prefix}/lib/libvcddec.a

+%{prefix}/lib/libvcddec.la

+%{prefix}/lib/libvcddec.so

+

diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/addrcache.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/addrcache.cc
new file mode 100644
index 0000000..2948266
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/addrcache.cc
@@ -0,0 +1,331 @@
+// Copyright 2007 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Implementation of the Address Cache and Address Encoding
+// algorithms described in sections 5.1 - 5.4 of RFC 3284 -
+// The VCDIFF Generic Differencing and Compression Data Format.
+// The RFC text can be found at http://www.faqs.org/rfcs/rfc3284.html
+//
+// Assumptions:
+//   * The VCDAddress type is large enough to hold any offset within
+//     the source and target windows.  The limit (for int32_t) is 2^31-1 bytes.
+//     The source (dictionary) should not approach this size limit;
+//     to compress a target file that is larger than
+//     INT_MAX - (dictionary size) bytes, the encoder must
+//     break it up into multiple target windows.
+
+#include <config.h>
+#include "addrcache.h"
+#include "logging.h"
+#include "varint_bigendian.h"
+#include "vcdiff_defs.h"  // RESULT_ERROR
+
+namespace open_vcdiff {
+
+// The constructor does not initialize near_addresses_ and same_addresses_.
+// Therefore, Init() must be called before any other method can be used.
+//
+// Arguments:
+//   near_cache_size: Size of the NEAR cache (number of 4-byte integers)
+//   same_cache_size: Size of the SAME cache (number of blocks of
+//                                            256 4-byte integers per block)
+//     Because the mode is expressed as a byte value,
+//     near_cache_size + same_cache_size should not exceed 254.
+//
+VCDiffAddressCache::VCDiffAddressCache(int near_cache_size,
+                                       int same_cache_size)
+    : near_cache_size_(near_cache_size),
+      same_cache_size_(same_cache_size),
+      next_slot_(0) { }
+
+VCDiffAddressCache::VCDiffAddressCache()
+    : near_cache_size_(kDefaultNearCacheSize),
+      same_cache_size_(kDefaultSameCacheSize),
+      next_slot_(0) { }
+
+// Sets up data structures needed to call other methods.  Operations that may
+// fail at runtime (for example, validating the provided near_cache_size_ and
+// same_cache_size_ parameters against their maximum allowed values) are
+// confined to this routine in order to guarantee that the class constructor
+// will never fail.  Other methods (except the destructor) cannot be invoked
+// until this method has been called successfully.  After the object has been
+// initialized and used, Init() can be called again to reset it to its initial
+// state.
+//
+// Return value: "true" if initialization succeeded, "false" if it failed.
+//     No other method except the destructor may be invoked if this function
+//     returns false.  The caller is responsible for checking the return value
+//     and providing an exit path in case of error.
+//
+bool VCDiffAddressCache::Init() {
+  // The mode is expressed as a byte value, so there is only room for 256 modes,
+  // including the two non-cached modes (SELF and HERE).  Do not allow a larger
+  // number of modes to be defined.  We do a separate sanity check for
+  // near_cache_size_ and same_cache_size_ because adding them together can
+  // cause an integer overflow if each is set to, say, INT_MAX.
+  if ((near_cache_size_ > (VCD_MAX_MODES - 2)) || (near_cache_size_ < 0)) {
+    LOG(ERROR) << "Near cache size " << near_cache_size_ << " is invalid"
+               << LOG_ENDL;
+    return false;
+  }
+  if ((same_cache_size_ > (VCD_MAX_MODES - 2)) || (same_cache_size_ < 0)) {
+    LOG(ERROR) << "Same cache size " << same_cache_size_ << " is invalid"
+               << LOG_ENDL;
+    return false;
+  }
+  if ((near_cache_size_ + same_cache_size_) > VCD_MAX_MODES - 2) {
+    LOG(ERROR) << "Using near cache size " << near_cache_size_
+               << " and same cache size " << same_cache_size_
+               << " would exceed maximum number of COPY modes ("
+               << VCD_MAX_MODES << ")" << LOG_ENDL;
+    return false;
+  }
+  if (near_cache_size_ > 0) {
+    near_addresses_.assign(near_cache_size_, 0);
+  }
+  if (same_cache_size_ > 0) {
+    same_addresses_.assign(same_cache_size_ * 256, 0);
+  }
+  next_slot_ = 0;  // in case Init() is called a second time to reinit
+  return true;
+}
+
+// This method will be called whenever an address is calculated for an
+// encoded or decoded COPY instruction, and will update the contents
+// of the SAME and NEAR caches.  It is vital that the use of
+// UpdateCache (called cache_update in the RFC examples) exactly match
+// the RFC standard, and that the same caching logic be used in the
+// decoder as in the encoder, in order for the decoded addresses to
+// match.
+//
+// Argument:
+//   address: This must be a valid address between 0 and
+//       (source window size + target window size).  It is assumed that
+//       these bounds have been checked before calling UpdateCache.
+//
+void VCDiffAddressCache::UpdateCache(VCDAddress address) {
+  if (near_cache_size_ > 0) {
+    near_addresses_[next_slot_] = address;
+    next_slot_ = (next_slot_ + 1) % near_cache_size_;
+  }
+  if (same_cache_size_ > 0) {
+    same_addresses_[address % (same_cache_size_ * 256)] = address;
+  }
+}
+
+// Determines the address mode that yields the most compact encoding
+// of the given address value, writes the encoded address into the
+// address stream, and returns the mode used.  The most compact encoding
+// is found by looking for the numerically lowest encoded address.
+// The Init() function must already have been called.
+//
+// Arguments:
+//   address: The address to be encoded.  Must be a non-negative integer
+//       between 0 and (here_address - 1).
+//   here_address: The current location in the target data (i.e., the
+//       position just after the last encoded value.)  Must be non-negative.
+//   encoded_addr: Points to an VCDAddress that will be replaced
+//       with the encoded representation of address.
+//       If WriteAddressAsVarintForMode returns true when passed
+//       the return value, then encoded_addr should be written
+//       into the delta file as a variable-length integer (Varint);
+//       otherwise, it should be written as a byte (unsigned char).
+//
+// Return value: A mode value between 0 and 255.  The mode will tell
+//       how to interpret the next value in the address stream.
+//       The values 0 and 1 correspond to SELF and HERE addressing.
+//
+// The function is guaranteed to succeed unless the conditions on the arguments
+// have not been met, in which case a LOG(DFATAL) message will be produced,
+// 0 will be returned, and *encoded_addr will be replaced with 0.
+//
+unsigned char VCDiffAddressCache::EncodeAddress(VCDAddress address,
+                                                VCDAddress here_address,
+                                                VCDAddress* encoded_addr) {
+  if (address < 0) {
+    LOG(DFATAL) << "EncodeAddress was passed a negative address: "
+                << address << LOG_ENDL;
+    *encoded_addr = 0;
+    return 0;
+  }
+  if (address >= here_address) {
+    LOG(DFATAL) << "EncodeAddress was called with address (" << address
+                << ") < here_address (" << here_address << ")" << LOG_ENDL;
+    *encoded_addr = 0;
+    return 0;
+  }
+  // Try using the SAME cache.  This method, if available, always
+  // results in the smallest encoding and takes priority over other modes.
+  if (same_cache_size() > 0) {
+    const VCDAddress same_cache_pos =
+        address % (same_cache_size() * 256);
+    if (SameAddress(same_cache_pos) == address) {
+      // This is the only mode for which an single byte will be written
+      // to the address stream instead of a variable-length integer.
+      UpdateCache(address);
+      *encoded_addr = same_cache_pos % 256;
+      return FirstSameMode() + (same_cache_pos / 256);  // SAME mode
+    }
+  }
+
+  // Try SELF mode
+  unsigned char best_mode = VCD_SELF_MODE;
+  VCDAddress best_encoded_address = address;
+
+  // Try HERE mode
+  {
+    const VCDAddress here_encoded_address = here_address - address;
+    if (here_encoded_address < best_encoded_address) {
+      best_mode = VCD_HERE_MODE;
+      best_encoded_address = here_encoded_address;
+    }
+  }
+
+  // Try using the NEAR cache
+  for (int i = 0; i < near_cache_size(); ++i) {
+    const VCDAddress near_encoded_address = address - NearAddress(i);
+    if ((near_encoded_address >= 0) &&
+        (near_encoded_address < best_encoded_address)) {
+      best_mode = FirstNearMode() + i;
+      best_encoded_address = near_encoded_address;
+    }
+  }
+
+  UpdateCache(address);
+  *encoded_addr = best_encoded_address;
+  return best_mode;
+}
+
+// Increments *byte_pointer and returns the byte it pointed to before the
+// increment.  The caller must check bounds to ensure that *byte_pointer
+// points to a valid address in memory.
+static unsigned char ParseByte(const char** byte_pointer) {
+  unsigned char byte_value = static_cast<unsigned char>(**byte_pointer);
+  ++(*byte_pointer);
+  return byte_value;
+}
+
+// Checks the given decoded address for validity.  Returns true if the
+// address is valid; otherwise, prints an error message to the log and
+// returns false.
+static bool IsDecodedAddressValid(VCDAddress decoded_address,
+                                  VCDAddress here_address) {
+  if (decoded_address < 0) {
+    LOG(ERROR) << "Decoded address " << decoded_address << " is invalid"
+               << LOG_ENDL;
+    return false;
+  } else if (decoded_address >= here_address) {
+    LOG(ERROR) << "Decoded address (" << decoded_address
+               << ") is beyond location in target file (" << here_address
+               << ")" << LOG_ENDL;
+    return false;
+  }
+  return true;
+}
+
+// Interprets the next value in the address_stream using the provided mode,
+// which may need to access the SAME or NEAR address cache.  Returns the
+// decoded address.
+// The Init() function must already have been called.
+//
+// Arguments:
+//   here_address: The current location in the source + target data (i.e., the
+//       location into which the COPY instruction will copy.)  By definition,
+//       all addresses between 0 and (here_address - 1) are valid, and
+//       any other address is invalid.
+//   mode: A byte value between 0 and (near_cache_size_ + same_cache_size_ + 1)
+//       which tells how to interpret the next value in the address stream.
+//       The values 0 and 1 correspond to SELF and HERE addressing.
+//       The validity of "mode" should already have been checked before
+//       calling this function.
+//   address_stream: Points to a pointer holding the position
+//       in the "Addresses section for COPYs" part of the input data.
+//       That section must already have been uncompressed
+//       using a secondary decompressor (if necessary.)
+//       This is an IN/OUT argument; the value of *address_stream will be
+//       incremented by the size of an integer, or (if the SAME cache
+//       was used) by the size of a byte (1).
+//   address_stream_end: Points to the position just after the end of
+//       the address stream buffer.  All addresses between *address_stream
+//       and address_stream_end should contain valid address data.
+//
+// Return value: If the input conditions were met, and the address section
+//     of the input data contains properly encoded addresses that match
+//     the instructions section, then an integer between 0 and here_address - 1
+//     will be returned, representing the address from which data should
+//     be copied from the source or target window into the output stream.
+//     If an invalid address value is found in address_stream, then
+//     RESULT_ERROR will be returned.  If the limit address_stream_end
+//     is reached before the address can be decoded, then
+//     RESULT_END_OF_DATA will be returned.  If more streamed data
+//     is expected, this means that the consumer should block and wait
+//     for more data before continuing to decode.  If no more data is expected,
+//     this return value signals an error condition.
+//
+VCDAddress VCDiffAddressCache::DecodeAddress(VCDAddress here_address,
+                                             unsigned char mode,
+                                             const char** address_stream,
+                                             const char* address_stream_end) {
+  if (here_address < 0) {
+    LOG(DFATAL) << "DecodeAddress was passed a negative value"
+                   " for here_address: " << here_address << LOG_ENDL;
+    return RESULT_ERROR;
+  }
+  const char* new_address_pos = *address_stream;
+  if (new_address_pos >= address_stream_end) {
+    return RESULT_END_OF_DATA;
+  }
+  VCDAddress decoded_address;
+  if (IsSameMode(mode)) {
+    // SAME mode expects a byte value as the encoded address
+    unsigned char encoded_address = ParseByte(&new_address_pos);
+    decoded_address = DecodeSameAddress(mode, encoded_address);
+  } else {
+    // All modes except SAME mode expect a VarintBE as the encoded address
+    int32_t encoded_address = VarintBE<int32_t>::Parse(address_stream_end,
+                                                       &new_address_pos);
+    switch (encoded_address) {
+      case RESULT_ERROR:
+        LOG(ERROR) << "Found invalid variable-length integer "
+                      "as encoded address value" << LOG_ENDL;
+        return RESULT_ERROR;
+      case RESULT_END_OF_DATA:
+        return RESULT_END_OF_DATA;
+      default:
+        break;
+    }
+    if (IsSelfMode(mode)) {
+      decoded_address = DecodeSelfAddress(encoded_address);
+    } else if (IsHereMode(mode)) {
+      decoded_address = DecodeHereAddress(encoded_address, here_address);
+    } else if (IsNearMode(mode)) {
+      decoded_address = DecodeNearAddress(mode, encoded_address);
+    } else {
+      LOG(DFATAL) << "Invalid mode value (" << static_cast<int>(mode)
+                  << ") passed to DecodeAddress; maximum mode value = "
+                  << static_cast<int>(LastMode()) << LOG_ENDL;
+      return RESULT_ERROR;
+    }
+  }
+  // Check for an out-of-bounds address (corrupt/malicious data)
+  if (!IsDecodedAddressValid(decoded_address, here_address)) {
+    return RESULT_ERROR;
+  }
+  *address_stream = new_address_pos;
+  UpdateCache(decoded_address);
+  return decoded_address;
+}
+
+}  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/addrcache.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/addrcache.h
new file mode 100644
index 0000000..f2862e8
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/addrcache.h
@@ -0,0 +1,218 @@
+// Copyright 2007 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Classes to implement the Address Cache and Address Encoding
+// algorithms described in sections 5.1 - 5.4 of RFC 3284 -
+// The VCDIFF Generic Differencing and Compression Data Format.
+// The RFC text can be found at http://www.faqs.org/rfcs/rfc3284.html
+
+#ifndef OPEN_VCDIFF_ADDRCACHE_H_
+#define OPEN_VCDIFF_ADDRCACHE_H_
+
+#include <config.h>
+#include <cstring>             // memset
+#include <vector>
+#include "vcdiff_defs.h"  // VCDAddress
+
+namespace open_vcdiff {
+
+// Implements the "same" and "near" caches
+// as described in RFC 3284, section 5.  The "near" cache allows
+// efficient reuse of one of the last four referenced addresses
+// plus a small offset, and the "same" cache allows efficient reuse
+// of an exact recent address distinguished by its lowest-order bits.
+//
+// NOT threadsafe.
+//
+class VCDiffAddressCache {
+ public:
+  // The default cache sizes specified in the RFC
+  static const int kDefaultNearCacheSize = 4;
+  static const int kDefaultSameCacheSize = 3;
+
+  VCDiffAddressCache(int near_cache_size, int same_cache_size);
+
+  // This version of the constructor uses the default values
+  // kDefaultNearCacheSize and kDefaultSameCacheSize.
+  VCDiffAddressCache();
+
+  // Initializes the object before use.  This method must be called after
+  // constructing a VCDiffAddressCache/ object, before any other method may be
+  // called.  This is because Init() validates near_cache_size_ and
+  // same_cache_size_ before initializing the same and near caches.  After the
+  // object has been initialized and used, Init() can be called again to reset
+  // it to its initial state.
+  //
+  bool Init();
+
+  int near_cache_size() const { return near_cache_size_; }
+
+  int same_cache_size() const { return same_cache_size_; }
+
+  // Returns the first mode number that represents one of the NEAR modes.
+  // The number of NEAR modes is near_cache_size.  Each NEAR mode refers to
+  // an element of the near_addresses_ array, where a recently-referenced
+  // address is stored.
+  //
+  static const unsigned char FirstNearMode() {
+    return VCD_FIRST_NEAR_MODE;
+  }
+
+  // Returns the first mode number that represents one of the SAME modes.
+  // The number of SAME modes is same_cache_size.  Each SAME mode refers to
+  // a block of 256 elements of the same_addresses_ array; the lowest-order
+  // 8 bits of the address are used to find the element of this block that
+  // may match the desired address value.
+  //
+  const unsigned char FirstSameMode() const {
+    return VCD_FIRST_NEAR_MODE + near_cache_size();
+  }
+
+  // Returns the maximum valid mode number, which happens to be
+  // the last SAME mode.
+  //
+  const unsigned char LastMode() const {
+    return FirstSameMode() + same_cache_size() - 1;
+  }
+
+  static const unsigned char DefaultLastMode() {
+    return VCD_FIRST_NEAR_MODE
+        + kDefaultNearCacheSize + kDefaultSameCacheSize - 1;
+  }
+
+  // See the definition of enum VCDiffModes in vcdiff_defs.h,
+  // as well as section 5.3 of the RFC, for a description of
+  // each address mode type (SELF, HERE, NEAR, and SAME).
+  static bool IsSelfMode(unsigned char mode) {
+    return mode == VCD_SELF_MODE;
+  }
+
+  static bool IsHereMode(unsigned char mode) {
+    return mode == VCD_HERE_MODE;
+  }
+
+  bool IsNearMode(unsigned char mode) const {
+    return (mode >= FirstNearMode()) && (mode < FirstSameMode());
+  }
+
+  bool IsSameMode(unsigned char mode) const {
+    return (mode >= FirstSameMode()) && (mode <= LastMode());
+  }
+
+  static VCDAddress DecodeSelfAddress(int32_t encoded_address) {
+    return encoded_address;
+  }
+
+  static VCDAddress DecodeHereAddress(int32_t encoded_address,
+                                      VCDAddress here_address) {
+    return here_address - encoded_address;
+  }
+
+  VCDAddress DecodeNearAddress(unsigned char mode,
+                               int32_t encoded_address) const {
+    return NearAddress(mode - FirstNearMode()) + encoded_address;
+  }
+
+  VCDAddress DecodeSameAddress(unsigned char mode,
+                               unsigned char encoded_address) const {
+    return SameAddress(((mode - FirstSameMode()) * 256) + encoded_address);
+  }
+
+  // Returns true if, when using the given mode, an encoded address
+  // should be written to the delta file as a variable-length integer;
+  // returns false if the encoded address should be written
+  // as a byte value (unsigned char).
+  bool WriteAddressAsVarintForMode(unsigned char mode) const {
+    return !IsSameMode(mode);
+  }
+
+  // An accessor for an element of the near_addresses_ array.
+  // No bounds checking is performed; the caller must ensure that
+  // Init() has already been called, and that
+  //     0 <= pos < near_cache_size_
+  //
+  VCDAddress NearAddress(int pos) const {
+    return near_addresses_[pos];
+  }
+
+  // An accessor for an element of the same_addresses_ array.
+  // No bounds checking is performed; the caller must ensure that
+  // Init() has already been called, and that
+  //     0 <= pos < (same_cache_size_ * 256)
+  //
+  VCDAddress SameAddress(int pos) const {
+    return same_addresses_[pos];
+  }
+
+  // This method will be called whenever an address is calculated for an
+  // encoded or decoded COPY instruction, and will update the contents
+  // of the SAME and NEAR caches.
+  //
+  void UpdateCache(VCDAddress address);
+
+  // Determines the address mode that yields the most compact encoding
+  // of the given address value.  The most compact encoding
+  // is found by looking for the numerically lowest encoded address.
+  // Sets *encoded_addr to the encoded representation of the address
+  // and returns the mode used.
+  //
+  // The caller should pass the return value to the method
+  // WriteAddressAsVarintForMode() to determine whether encoded_addr
+  // should be written to the delta file as a variable-length integer
+  // or as a byte (unsigned char).
+  //
+  unsigned char EncodeAddress(VCDAddress address,
+                              VCDAddress here_address,
+                              VCDAddress* encoded_addr);
+
+  // Interprets the next value in the address_stream using the provided mode,
+  // which may need to access the SAME or NEAR address cache.  Returns the
+  // decoded address, or one of the following values:
+  //   RESULT_ERROR: An invalid address value was found in address_stream.
+  //   RESULT_END_OF_DATA: The limit address_stream_end was reached before
+  //       the address could be decoded.  If more streamed data is expected,
+  //       this means that the consumer should block and wait for more data
+  //       before continuing to decode.  If no more data is expected, this
+  //       return value signals an error condition.
+  //
+  // If successful, *address_stream will be incremented past the decoded address
+  // position.  If RESULT_ERROR or RESULT_END_OF_DATA is returned,
+  // then the value of *address_stream will not have changed.
+  //
+  VCDAddress DecodeAddress(VCDAddress here_address,
+                           unsigned char mode,
+                           const char** address_stream,
+                           const char* address_stream_end);
+
+ private:
+  // The number of addresses to be kept in the NEAR cache.
+  const int near_cache_size_;
+  // The number of 256-byte blocks to store in the SAME cache.
+  const int same_cache_size_;
+  // The next position in the NEAR cache to which an address will be written.
+  int       next_slot_;
+  // NEAR cache contents
+  std::vector<VCDAddress> near_addresses_;
+  // SAME cache contents
+  std::vector<VCDAddress> same_addresses_;
+
+  // Making these private avoids implicit copy constructor & assignment operator
+  VCDiffAddressCache(const VCDiffAddressCache&);  // NOLINT
+  void operator=(const VCDiffAddressCache&);
+};
+
+}  // namespace open_vcdiff
+
+#endif  // OPEN_VCDIFF_ADDRCACHE_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/addrcache_test.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/addrcache_test.cc
new file mode 100644
index 0000000..2e7632d
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/addrcache_test.cc
@@ -0,0 +1,670 @@
+// Copyright 2007 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <config.h>
+#include "addrcache.h"
+#include <stdint.h>  // uint32_t
+#include <climits>  // INT_MAX, INT_MIN
+#include <cstdlib>  // rand, srand
+#include <string>
+#include <vector>
+#include "logging.h"
+#include "testing.h"
+#include "varint_bigendian.h"
+#include "vcdiff_defs.h"  // RESULT_ERROR
+
+namespace open_vcdiff {
+
+using std::string;
+
+namespace {
+
+// Provides an address_stream_ buffer and functions to manually encode
+// values into the buffer, and to manually decode and verify test results
+// from the buffer.
+//
+class VCDiffAddressCacheTest : public testing::Test {
+ public:
+  VCDiffAddressCacheTest() : decode_position_(NULL),
+                             decode_position_end_(NULL),
+                             verify_encode_position_(NULL),
+                             last_encode_size_(0),
+                             last_decode_position_(NULL) { }
+
+  virtual ~VCDiffAddressCacheTest() { }
+
+  virtual void SetUp() {
+    EXPECT_TRUE(cache_.Init());
+  }
+
+  // Benchmarks for timing encode/decode operations
+  void BM_Setup(int test_size, bool print_stats);
+  void BM_CacheEncode(int iterations, int test_size);
+  void BM_CacheDecode(int iterations, int test_size);
+
+ protected:
+  virtual void TestBody() { }  // to allow instantiation of this class
+
+  void BeginDecode() {
+    decode_position_ = address_stream_.data();
+    EXPECT_TRUE(decode_position_ != NULL);
+    last_decode_position_ = decode_position_;
+    decode_position_end_ = decode_position_ + address_stream_.size();
+  }
+
+  void ExpectEncodedSizeInBytes(int n) {
+    EXPECT_EQ(last_encode_size_ + n, address_stream_.size());
+    last_encode_size_ = address_stream_.size();
+  }
+
+  void ExpectDecodedSizeInBytes(int n) {
+    EXPECT_EQ(last_decode_position_ + n, decode_position_);
+    last_decode_position_ = decode_position_;
+  }
+
+  void ManualEncodeVarint(VCDAddress value) {
+    VarintBE<VCDAddress>::AppendToString(value, &address_stream_);
+  }
+
+  void ManualEncodeByte(unsigned char byte) {
+    address_stream_.push_back(byte);
+  }
+
+  void ExpectEncodedVarint(VCDAddress expected_value, int expected_size) {
+    if (!verify_encode_position_) {
+      verify_encode_position_ = address_stream_.data();
+    }
+    EXPECT_EQ(expected_size, VarintBE<VCDAddress>::Length(expected_value));
+    VCDAddress output_val = VarintBE<VCDAddress>::Parse(
+        address_stream_.data() + address_stream_.size(),
+        &verify_encode_position_);
+    EXPECT_EQ(expected_value, output_val);
+  }
+
+  void ExpectEncodedByte(unsigned char expected_value) {
+    if (!verify_encode_position_) {
+      verify_encode_position_ = address_stream_.data();
+    }
+    EXPECT_EQ(expected_value, *verify_encode_position_);
+    ++verify_encode_position_;
+  }
+
+  void TestEncode(VCDAddress address,
+                  VCDAddress here_address,
+                  unsigned char mode,
+                  int size) {
+    VCDAddress encoded_addr = 0;
+    EXPECT_EQ(mode, cache_.EncodeAddress(address, here_address, &encoded_addr));
+    if (cache_.WriteAddressAsVarintForMode(mode)) {
+      ManualEncodeVarint(encoded_addr);
+    } else {
+      EXPECT_GT(256, encoded_addr);
+      ManualEncodeByte(static_cast<unsigned char>(encoded_addr));
+    }
+    ExpectEncodedSizeInBytes(size);
+  }
+
+  VCDiffAddressCache cache_;
+  string address_stream_;
+  const char* decode_position_;
+  const char* decode_position_end_;
+  string large_address_stream_;
+  std::vector<unsigned char> mode_stream_;
+  std::vector<VCDAddress> verify_stream_;
+
+ private:
+  const char* verify_encode_position_;
+  string::size_type last_encode_size_;
+  const char*       last_decode_position_;
+};
+
+#ifdef GTEST_HAS_DEATH_TEST
+// This synonym is needed for the tests that use ASSERT_DEATH
+typedef VCDiffAddressCacheTest VCDiffAddressCacheDeathTest;
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Having either or both cache size == 0 is acceptable
+TEST_F(VCDiffAddressCacheTest, ZeroCacheSizes) {
+  VCDiffAddressCache zero_cache(0, 0);
+  EXPECT_TRUE(zero_cache.Init());
+}
+
+TEST_F(VCDiffAddressCacheTest, NegativeCacheSizes) {
+  VCDiffAddressCache negative_cache(-1, -1);   // The constructor must not fail
+  EXPECT_FALSE(negative_cache.Init());
+}
+
+TEST_F(VCDiffAddressCacheTest, OnlySameCacheSizeIsNegative) {
+  VCDiffAddressCache negative_cache(0, -1);   // The constructor must not fail
+  EXPECT_FALSE(negative_cache.Init());
+}
+
+TEST_F(VCDiffAddressCacheTest, ExtremePositiveCacheSizes) {
+  // The constructor must not fail
+  VCDiffAddressCache int_max_cache(INT_MAX, INT_MAX);
+  EXPECT_FALSE(int_max_cache.Init());
+}
+
+TEST_F(VCDiffAddressCacheTest, ExtremeNegativeCacheSizes) {
+  // The constructor must not fail
+  VCDiffAddressCache int_min_cache(INT_MIN, INT_MIN);
+  EXPECT_FALSE(int_min_cache.Init());
+}
+
+// VCD_MAX_MODES is the maximum number of modes, including SAME and HERE modes.
+// So neither the SAME cache nor the HERE cache can be larger than
+// (VCD_MAX_MODES - 2).
+TEST_F(VCDiffAddressCacheTest, NearCacheSizeIsTooBig) {
+  VCDiffAddressCache negative_cache(VCD_MAX_MODES - 1, 0);
+  EXPECT_FALSE(negative_cache.Init());
+}
+
+TEST_F(VCDiffAddressCacheTest, SameCacheSizeIsTooBig) {
+  VCDiffAddressCache negative_cache(0, VCD_MAX_MODES - 1);
+  EXPECT_FALSE(negative_cache.Init());
+}
+
+TEST_F(VCDiffAddressCacheTest, CombinedSizesAreTooBig) {
+  VCDiffAddressCache negative_cache((VCD_MAX_MODES / 2),
+                                    (VCD_MAX_MODES / 2) - 1);
+  EXPECT_FALSE(negative_cache.Init());
+}
+
+TEST_F(VCDiffAddressCacheTest, MaxLegalNearCacheSize) {
+  VCDiffAddressCache negative_cache(VCD_MAX_MODES - 2, 0);
+  EXPECT_TRUE(negative_cache.Init());
+}
+
+TEST_F(VCDiffAddressCacheTest, MaxLegalSameCacheSize) {
+  VCDiffAddressCache negative_cache(0, VCD_MAX_MODES - 2);
+  EXPECT_TRUE(negative_cache.Init());
+}
+
+TEST_F(VCDiffAddressCacheTest, MaxLegalCombinedSizes) {
+  VCDiffAddressCache negative_cache((VCD_MAX_MODES / 2) - 1,
+                                    (VCD_MAX_MODES / 2) - 1);
+  EXPECT_TRUE(negative_cache.Init());
+}
+
+TEST_F(VCDiffAddressCacheTest, DestroyWithoutInitialization) {
+  VCDiffAddressCache no_init_cache(4, 3);
+  // Should be destroyed without crashing
+}
+
+TEST_F(VCDiffAddressCacheTest, DestroyDefaultWithoutInitialization) {
+  VCDiffAddressCache no_init_cache;
+  // Should be destroyed without crashing
+}
+
+TEST_F(VCDiffAddressCacheTest, CacheContentsInitiallyZero) {
+  VCDAddress test_address = 0;
+  // Check that caches are initially set to zero
+  for (test_address = 0; test_address < 4; ++test_address) {
+    EXPECT_EQ(0, cache_.NearAddress(test_address));
+  }
+  for (test_address = 0; test_address < 256 * 3; ++test_address) {
+    EXPECT_EQ(0, cache_.SameAddress(test_address));
+  }
+}
+
+// Inserts values 1, 2, ... , 10 into the cache and tests its entire
+// contents for consistency.
+//
+TEST_F(VCDiffAddressCacheTest, InsertFirstTen) {
+  VCDAddress test_address = 0;
+  for (test_address = 1; test_address <= 10; ++test_address) {
+    cache_.UpdateCache(test_address);
+  }
+  EXPECT_EQ(9, cache_.NearAddress(0));   // slot 0: 1 => 5 => 9
+  EXPECT_EQ(10, cache_.NearAddress(1));  // slot 1: 2 => 6 => 10
+  EXPECT_EQ(7, cache_.NearAddress(2));   // slot 2: 3 => 7
+  EXPECT_EQ(8, cache_.NearAddress(3));   // slot 3: 4 => 8
+  EXPECT_EQ(0, cache_.SameAddress(0));
+  for (test_address = 1; test_address <= 10; ++test_address) {
+    EXPECT_EQ(test_address, cache_.SameAddress(test_address));
+  }
+  for (test_address = 11; test_address < 256 * 3; ++test_address) {
+    EXPECT_EQ(0, cache_.SameAddress(test_address));
+  }
+}
+
+TEST_F(VCDiffAddressCacheTest, InsertIntMax) {
+  cache_.UpdateCache(INT_MAX);
+  EXPECT_EQ(INT_MAX, cache_.NearAddress(0));
+  EXPECT_EQ(INT_MAX, cache_.SameAddress(INT_MAX % (256 * 3)));
+  EXPECT_EQ(0, cache_.SameAddress((INT_MAX - 256) % (256 * 3)));
+  EXPECT_EQ(0, cache_.SameAddress((INT_MAX - 512) % (256 * 3)));
+}
+
+// Exercises all four addressing mode types by encoding five values
+// with EncodeAddress.
+// Checks to see that the proper mode was selected in each case,
+// and that the encoding is correct.
+//
+TEST_F(VCDiffAddressCacheTest, EncodeAddressModes) {
+  TestEncode(0x0000FFFF, 0x10000000,  VCD_SELF_MODE, 3);
+  TestEncode(0x10000000, 0x10000010,  VCD_HERE_MODE, 1);
+  TestEncode(0x10000004, 0x10000020,  cache_.FirstNearMode() + 0x01, 1);
+  TestEncode(0x0FFFFFFE, 0x10000030,  VCD_HERE_MODE, 1);
+  TestEncode(0x10000004, 0x10000040,  cache_.FirstSameMode() + 0x01, 1);
+  ExpectEncodedVarint(0xFFFF, 3);  // SELF mode: addr 0x0000FFFF
+  ExpectEncodedVarint(0x10, 1);    // HERE mode: here - 0x10 = 0x10000000
+  ExpectEncodedVarint(0x04, 1);    // NEAR cache #1:
+                                   // last addr + 0x4 = 0x10000004
+  ExpectEncodedVarint(0x32, 1);    // HERE mode: here - 0x32 = 0x0FFFFFFE
+  ExpectEncodedByte(0x04);         // SAME cache #1: 0x10000004 hits
+}
+
+// Exercises all four addressing mode types by manually encoding six values
+// and calling DecodeAddress on each one.
+//
+TEST_F(VCDiffAddressCacheTest, DecodeAddressModes) {
+  ManualEncodeVarint(0xCAFE);
+  ManualEncodeVarint(0xCAFE);
+  ManualEncodeVarint(0x1000);
+  ManualEncodeByte(0xFE);   // SAME mode uses a byte, not a Varint
+  ManualEncodeVarint(0xFE);
+  ManualEncodeVarint(0x1000);
+  BeginDecode();
+  EXPECT_EQ(0xCAFE,
+            cache_.DecodeAddress(0x10000,
+                                 VCD_SELF_MODE,
+                                 &decode_position_,
+                                 decode_position_end_));
+  ExpectDecodedSizeInBytes(VarintBE<VCDAddress>::Length(0xCAFE));
+  EXPECT_EQ(0x20000 - 0xCAFE,
+            cache_.DecodeAddress(0x20000,
+                                 VCD_HERE_MODE,
+                                 &decode_position_,
+                                 decode_position_end_));
+  ExpectDecodedSizeInBytes(VarintBE<VCDAddress>::Length(0xCAFE));
+  EXPECT_EQ(0xDAFE,
+            cache_.DecodeAddress(0x30000,
+                                 cache_.FirstNearMode(),
+                                 &decode_position_,
+                                 decode_position_end_));
+  ExpectDecodedSizeInBytes(VarintBE<VCDAddress>::Length(0x1000));
+  EXPECT_EQ(0xCAFE,
+            cache_.DecodeAddress(0x40000,
+                                 cache_.FirstSameMode() + (0xCA % 3),
+                                 &decode_position_,
+                                 decode_position_end_));
+  ExpectDecodedSizeInBytes(sizeof(unsigned char));  // a byte, not a Varint
+  EXPECT_EQ(0xFE,
+            cache_.DecodeAddress(0x50000,
+                                 VCD_SELF_MODE,
+                                 &decode_position_,
+                                 decode_position_end_));
+  ExpectDecodedSizeInBytes(VarintBE<VCDAddress>::Length(0xFE));
+  // NEAR mode #0 has been overwritten by fifth computed addr (wrap around)
+  EXPECT_EQ(0x10FE,
+            cache_.DecodeAddress(0x60000,
+                                 cache_.FirstNearMode(),
+                                 &decode_position_,
+                                 decode_position_end_));
+  ExpectDecodedSizeInBytes(VarintBE<VCDAddress>::Length(0x1000));
+}
+
+// Test with both cache sizes == 0.  The encoder should not choose
+// a SAME or NEAR mode under these conditions.
+TEST_F(VCDiffAddressCacheTest, EncodeAddressZeroCacheSizes) {
+  VCDAddress encoded_addr = 0;
+  VCDiffAddressCache zero_cache(0, 0);
+  EXPECT_TRUE(zero_cache.Init());
+  EXPECT_EQ(VCD_SELF_MODE,
+            zero_cache.EncodeAddress(0x0000FFFF, 0x10000000, &encoded_addr));
+  EXPECT_EQ(0xFFFF, encoded_addr);
+  EXPECT_EQ(VCD_HERE_MODE,
+            zero_cache.EncodeAddress(0x10000000, 0x10000010, &encoded_addr));
+  EXPECT_EQ(0x10, encoded_addr);
+  EXPECT_EQ(VCD_HERE_MODE,
+            zero_cache.EncodeAddress(0x10000004, 0x10000020, &encoded_addr));
+  EXPECT_EQ(0x1C, encoded_addr);
+  EXPECT_EQ(VCD_HERE_MODE,
+            zero_cache.EncodeAddress(0x0FFFFFFE, 0x10000030, &encoded_addr));
+  EXPECT_EQ(0x32, encoded_addr);
+  EXPECT_EQ(VCD_HERE_MODE,
+            zero_cache.EncodeAddress(0x10000004, 0x10000040, &encoded_addr));
+  EXPECT_EQ(0x3C, encoded_addr);
+}
+
+TEST_F(VCDiffAddressCacheTest, DecodeAddressZeroCacheSizes) {
+  VCDiffAddressCache zero_cache(0, 0);
+  EXPECT_TRUE(zero_cache.Init());
+  ManualEncodeVarint(0xCAFE);
+  ManualEncodeVarint(0xCAFE);
+  ManualEncodeVarint(0xDAFE);
+  BeginDecode();
+  EXPECT_EQ(0xCAFE, zero_cache.DecodeAddress(0x10000,
+                                             VCD_SELF_MODE,
+                                             &decode_position_,
+                                             decode_position_end_));
+  ExpectDecodedSizeInBytes(VarintBE<VCDAddress>::Length(0xCAFE));
+  EXPECT_EQ(0x20000 - 0xCAFE, zero_cache.DecodeAddress(0x20000,
+                                                       VCD_HERE_MODE,
+                                                       &decode_position_,
+                                                       decode_position_end_));
+  ExpectDecodedSizeInBytes(VarintBE<VCDAddress>::Length(0xCAFE));
+  EXPECT_EQ(0xDAFE, zero_cache.DecodeAddress(0x30000,
+                                             VCD_SELF_MODE,
+                                             &decode_position_,
+                                             decode_position_end_));
+  ExpectDecodedSizeInBytes(VarintBE<VCDAddress>::Length(0xDAFE));
+}
+
+#ifdef GTEST_HAS_DEATH_TEST
+TEST_F(VCDiffAddressCacheDeathTest, EncodeNegativeAddress) {
+  VCDAddress dummy_encoded_address = 0;
+  EXPECT_DEBUG_DEATH(cache_.EncodeAddress(-1, -1, &dummy_encoded_address),
+                     "negative");
+}
+
+TEST_F(VCDiffAddressCacheDeathTest, EncodeAddressPastHereAddress) {
+  VCDAddress dummy_encoded_address = 0;
+  EXPECT_DEBUG_DEATH(cache_.EncodeAddress(0x100, 0x100, &dummy_encoded_address),
+                     "address.*<.*here_address");
+  EXPECT_DEBUG_DEATH(cache_.EncodeAddress(0x200, 0x100, &dummy_encoded_address),
+                     "address.*<.*here_address");
+}
+
+TEST_F(VCDiffAddressCacheDeathTest, DecodeInvalidMode) {
+  ManualEncodeVarint(0xCAFE);
+  BeginDecode();
+  EXPECT_DEBUG_DEATH(EXPECT_EQ(RESULT_ERROR,
+                               cache_.DecodeAddress(0x10000000,
+                                                    cache_.LastMode() + 1,
+                                                    &decode_position_,
+                                                    decode_position_end_)),
+                     "mode");
+  EXPECT_DEBUG_DEATH(EXPECT_EQ(RESULT_ERROR,
+                               cache_.DecodeAddress(0x10000000,
+                                                    0xFF,
+                                                    &decode_position_,
+                                                    decode_position_end_)),
+                     "mode");
+  ExpectDecodedSizeInBytes(0);  // Should not modify decode_position_
+}
+
+TEST_F(VCDiffAddressCacheDeathTest, DecodeZeroOrNegativeHereAddress) {
+  ManualEncodeVarint(0xCAFE);
+  ManualEncodeVarint(0xCAFE);
+  BeginDecode();
+  // Using a Debug build, the check will fail; using a Release build,
+  // the check will not occur, and the SELF mode does not depend on
+  // the value of here_address, so DecodeAddress() will succeed.
+  EXPECT_DEBUG_DEATH(cache_.DecodeAddress(-1,
+                                          VCD_SELF_MODE,
+                                          &decode_position_,
+                                          decode_position_end_),
+                     "negative");
+  // A zero value for here_address should not kill the decoder,
+  // but instead should return an error value.  A delta file may contain
+  // a window that has no source segment and that (erroneously)
+  // uses a COPY instruction as its first instruction.  This should
+  // cause an error to be reported, not a debug check failure.
+  EXPECT_EQ(RESULT_ERROR, cache_.DecodeAddress(0,
+                                         VCD_SELF_MODE,
+                                         &decode_position_,
+                                         decode_position_end_));
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+TEST_F(VCDiffAddressCacheTest, DecodeAddressPastHereAddress) {
+  ManualEncodeVarint(0xCAFE);
+  BeginDecode();
+  EXPECT_EQ(RESULT_ERROR, cache_.DecodeAddress(0x1000,
+                                         VCD_SELF_MODE,
+                                         &decode_position_,
+                                         decode_position_end_));
+  ExpectDecodedSizeInBytes(0);  // Should not modify decode_position_
+}
+
+TEST_F(VCDiffAddressCacheTest, HereModeAddressTooLarge) {
+  ManualEncodeVarint(0x10001);  // here_address + 1
+  BeginDecode();
+  EXPECT_EQ(RESULT_ERROR, cache_.DecodeAddress(0x10000,
+                                         VCD_HERE_MODE,
+                                         &decode_position_,
+                                         decode_position_end_));
+  ExpectDecodedSizeInBytes(0);  // Should not modify decode_position_
+}
+
+TEST_F(VCDiffAddressCacheTest, NearModeAddressOverflow) {
+  ManualEncodeVarint(0xCAFE);
+  ManualEncodeVarint(0x7FFFFFFF);
+  BeginDecode();
+  EXPECT_EQ(0xCAFE, cache_.DecodeAddress(0x10000,
+                                         VCD_SELF_MODE,
+                                         &decode_position_,
+                                         decode_position_end_));
+  ExpectDecodedSizeInBytes(VarintBE<VCDAddress>::Length(0xCAFE));
+  // Now decode a NEAR mode address of base address 0xCAFE
+  // (the first decoded address) + offset 0x7FFFFFFF.  This will cause
+  // an integer overflow and should signal an error.
+  EXPECT_EQ(RESULT_ERROR, cache_.DecodeAddress(0x10000000,
+                                         cache_.FirstNearMode(),
+                                         &decode_position_,
+                                         decode_position_end_));
+  ExpectDecodedSizeInBytes(0);  // Should not modify decode_position_
+}
+
+// A Varint should contain at most 9 bytes that have their continuation bit
+// (the uppermost, or 7 bit) set.  A longer string of bytes that all have
+// bit 7 set is not a valid Varint.  Try to parse such a string as a Varint
+// and confirm that it does not run off the end of the input buffer and
+// it returns an error value (RESULT_ERROR).
+//
+TEST_F(VCDiffAddressCacheTest, DecodeInvalidVarint) {
+  address_stream_.clear();
+  // Write 512 0xFE bytes
+  address_stream_.append(512, static_cast<char>(0xFE));
+  BeginDecode();
+  EXPECT_EQ(RESULT_ERROR, cache_.DecodeAddress(0x10000000,
+                                         VCD_SELF_MODE,
+                                         &decode_position_,
+                                         decode_position_end_));
+  ExpectDecodedSizeInBytes(0);  // Should not modify decode_position_
+}
+
+// If only part of a Varint appears in the data to be decoded,
+// then DecodeAddress should return RESULT_END_OF_DATA,
+// which means that the Varint *may* be valid if there is more
+// data expected to be returned.
+//
+TEST_F(VCDiffAddressCacheTest, DecodePartialVarint) {
+  address_stream_.clear();
+  ManualEncodeByte(0xFE);
+  ManualEncodeByte(0xFE);
+  ManualEncodeByte(0xFE);
+  BeginDecode();
+  EXPECT_EQ(RESULT_END_OF_DATA,
+            cache_.DecodeAddress(0x10000000,
+                                 VCD_SELF_MODE,
+                                 &decode_position_,
+                                 decode_position_end_));
+  ExpectDecodedSizeInBytes(0);  // Should not modify decode_position_
+  // Now add the missing last byte (supposedly read from a stream of data)
+  // and verify that the Varint is now valid.
+  ManualEncodeByte(0x01);  // End the Varint with an additional byte
+  BeginDecode();  // Reset read position to start of data
+  EXPECT_EQ(0xFDFBF01,
+            cache_.DecodeAddress(0x10000000,
+                                 VCD_SELF_MODE,
+                                 &decode_position_,
+                                 decode_position_end_));
+  ExpectDecodedSizeInBytes(4);  // ManualEncodeByte was called for 4 byte values
+}
+
+#ifdef GTEST_HAS_DEATH_TEST
+TEST_F(VCDiffAddressCacheDeathTest, DecodeBadMode) {
+  ManualEncodeVarint(0xCAFE);
+  BeginDecode();
+  EXPECT_DEBUG_DEATH(EXPECT_EQ(RESULT_ERROR,
+                               cache_.DecodeAddress(0x10000,
+                                                    cache_.LastMode() + 1,
+                                                    &decode_position_,
+                                                    decode_position_end_)),
+                     "maximum");
+  ExpectDecodedSizeInBytes(0);
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+TEST_F(VCDiffAddressCacheTest, DecodeInvalidHereAddress) {
+  ManualEncodeVarint(0x10001);  // offset larger than here_address
+  BeginDecode();
+  EXPECT_EQ(RESULT_ERROR, cache_.DecodeAddress(0x10000,
+                                         VCD_HERE_MODE,
+                                         &decode_position_,
+                                         decode_position_end_));
+  ExpectDecodedSizeInBytes(0);
+}
+
+TEST_F(VCDiffAddressCacheTest, DecodeInvalidNearAddress) {
+  ManualEncodeVarint(0xCAFE);
+  ManualEncodeVarint(INT_MAX);  // offset will cause integer overflow
+  BeginDecode();
+  EXPECT_EQ(0xCAFE,
+            cache_.DecodeAddress(0x10000,
+                                 VCD_SELF_MODE,
+                                 &decode_position_,
+                                 decode_position_end_));
+  ExpectDecodedSizeInBytes(VarintBE<VCDAddress>::Length(0xCAFE));
+  EXPECT_EQ(RESULT_ERROR, cache_.DecodeAddress(0x10000,
+                                         cache_.FirstNearMode(),
+                                         &decode_position_,
+                                         decode_position_end_));
+  ExpectDecodedSizeInBytes(0);
+}
+
+void VCDiffAddressCacheTest::BM_Setup(int test_size, bool print_stats) {
+  mode_stream_.resize(test_size);
+  verify_stream_.resize(test_size);
+  VCDAddress here_address = 1;
+  srand(1);
+  for (int i = 0; i < test_size; ++i) {
+    verify_stream_[i] = PortableRandomInRange(here_address - 1);
+    here_address += 4;
+  }
+  BM_CacheEncode(1, test_size);  // populate large_address_stream_, mode_stream_
+  const size_t encoded_size_ = large_address_stream_.size();
+  if (print_stats) {
+    // Count the percentages of modes used
+    int self_count = 0, here_count = 0, near_count = 0, same_count = 0;
+    for (int i = 0; i < test_size; ++i) {
+      if (mode_stream_[i] == VCD_SELF_MODE) {
+        ++self_count;
+      } else if (mode_stream_[i] == VCD_HERE_MODE) {
+        ++here_count;
+      } else if (mode_stream_[i] < cache_.FirstSameMode()) {
+        ++near_count;
+      } else {
+        ++same_count;
+      }
+    }
+    const int original_bytes = test_size * sizeof(verify_stream_[0]);
+    const int mode_bytes = test_size * sizeof(mode_stream_[0]);
+    double percent_compression =
+      ((1 - (static_cast<double>(encoded_size_ + mode_bytes) / original_bytes))
+          * 100);
+    LOG(INFO) << "Encoded " << test_size << " addresses ("
+              << original_bytes << " bytes) into "
+              << encoded_size_ << " address bytes + "
+              << mode_bytes << " mode bytes: "
+              << percent_compression << "% compression" << LOG_ENDL;
+    LOG(INFO) << "SELF mode: " << self_count << " ("
+              << ((static_cast<double>(self_count) / test_size) * 100) << "%); "
+              << "HERE mode: " << here_count << " ("
+              << ((static_cast<double>(here_count) / test_size) * 100) << "%); "
+              << "NEAR mode: " << near_count << " ("
+              << ((static_cast<double>(near_count) / test_size) * 100) << "%); "
+              << "SAME mode: " << same_count << " ("
+              << ((static_cast<double>(same_count) / test_size) * 100) << "%)"
+              << LOG_ENDL;
+  }
+}
+
+void VCDiffAddressCacheTest::BM_CacheEncode(int iterations, int test_size) {
+  VCDAddress here_address = 1;
+  VCDAddress encoded_addr = 0;
+  for (int test_iteration = 0; test_iteration < iterations; ++test_iteration) {
+    cache_.Init();
+    large_address_stream_.clear();
+    here_address = 1;
+    for (int i = 0; i < test_size; ++i) {
+      const unsigned char mode = cache_.EncodeAddress(verify_stream_[i],
+                                                      here_address,
+                                                      &encoded_addr);
+      if (cache_.WriteAddressAsVarintForMode(mode)) {
+        VarintBE<VCDAddress>::AppendToString(encoded_addr,
+                                             &large_address_stream_);
+      } else {
+        EXPECT_GT(256, encoded_addr);
+        large_address_stream_.push_back(
+            static_cast<unsigned char>(encoded_addr));
+      }
+      mode_stream_[i] = mode;
+      here_address += 4;
+    }
+  }
+}
+
+void VCDiffAddressCacheTest::BM_CacheDecode(int iterations, int test_size) {
+  VCDAddress here_address = 1;
+  for (int test_iteration = 0; test_iteration < iterations; ++test_iteration) {
+    cache_.Init();
+    const char* large_decode_pointer = large_address_stream_.data();
+    const char* const end_of_encoded_data =
+        large_decode_pointer + large_address_stream_.size();
+    here_address = 1;
+    for (int i = 0; i < test_size; ++i) {
+      EXPECT_EQ(verify_stream_[i],
+                cache_.DecodeAddress(here_address,
+                                     mode_stream_[i],
+                                     &large_decode_pointer,
+                                     end_of_encoded_data));
+      here_address += 4;
+    }
+    EXPECT_EQ(end_of_encoded_data, large_decode_pointer);
+  }
+}
+
+TEST_F(VCDiffAddressCacheTest, PerformanceTest) {
+  const int test_size = 20 * 1024;  // 20K random encode/decode operations
+  const int num_iterations = 40;  // run test 40 times and take average
+  BM_Setup(test_size, true);
+  {
+    CycleTimer encode_timer;
+    encode_timer.Start();
+    BM_CacheEncode(num_iterations, test_size);
+    encode_timer.Stop();
+    double encode_time_in_ms =
+        static_cast<double>(encode_timer.GetInUsec()) / 1000;
+    LOG(INFO) << "Time to encode: "
+              << (encode_time_in_ms / num_iterations) << " ms" << LOG_ENDL;
+  }
+  {
+    CycleTimer decode_timer;
+    decode_timer.Start();
+    BM_CacheDecode(num_iterations, test_size);
+    decode_timer.Stop();
+    double decode_time_in_ms =
+        static_cast<double>(decode_timer.GetInUsec()) / 1000;
+    LOG(INFO) << "Time to decode: "
+              << (decode_time_in_ms / num_iterations) << " ms" << LOG_ENDL;
+  }
+}
+
+}  // unnamed namespace
+}  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/adler32.c b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/adler32.c
new file mode 100644
index 0000000..b8f37bb
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/adler32.c
@@ -0,0 +1,189 @@
+/* adler32.c -- compute the Adler-32 checksum of a data stream
+ * Copyright (C) 1995-2004 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+#define BASE 65521UL    /* largest prime smaller than 65536 */
+#define NMAX 5552
+/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
+
+#define DO1(buf,i)  {adler += (buf)[i]; sum2 += adler;}
+#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
+#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
+#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
+#define DO16(buf)   DO8(buf,0); DO8(buf,8);
+
+/* use NO_DIVIDE if your processor does not do division in hardware */
+#ifdef NO_DIVIDE
+#  define MOD(a) \
+    do { \
+        if (a >= (BASE << 16)) a -= (BASE << 16); \
+        if (a >= (BASE << 15)) a -= (BASE << 15); \
+        if (a >= (BASE << 14)) a -= (BASE << 14); \
+        if (a >= (BASE << 13)) a -= (BASE << 13); \
+        if (a >= (BASE << 12)) a -= (BASE << 12); \
+        if (a >= (BASE << 11)) a -= (BASE << 11); \
+        if (a >= (BASE << 10)) a -= (BASE << 10); \
+        if (a >= (BASE << 9)) a -= (BASE << 9); \
+        if (a >= (BASE << 8)) a -= (BASE << 8); \
+        if (a >= (BASE << 7)) a -= (BASE << 7); \
+        if (a >= (BASE << 6)) a -= (BASE << 6); \
+        if (a >= (BASE << 5)) a -= (BASE << 5); \
+        if (a >= (BASE << 4)) a -= (BASE << 4); \
+        if (a >= (BASE << 3)) a -= (BASE << 3); \
+        if (a >= (BASE << 2)) a -= (BASE << 2); \
+        if (a >= (BASE << 1)) a -= (BASE << 1); \
+        if (a >= BASE) a -= BASE; \
+    } while (0)
+#  define MOD4(a) \
+    do { \
+        if (a >= (BASE << 4)) a -= (BASE << 4); \
+        if (a >= (BASE << 3)) a -= (BASE << 3); \
+        if (a >= (BASE << 2)) a -= (BASE << 2); \
+        if (a >= (BASE << 1)) a -= (BASE << 1); \
+        if (a >= BASE) a -= BASE; \
+    } while (0)
+#else
+#  define MOD(a) a %= BASE
+#  define MOD4(a) a %= BASE
+#endif
+
+/* ========================================================================= */
+
+/* 
+   The adler32 code below computes, in effect,
+
+   uLong high = 0;
+   uLong low  = 1;
+   for (j = 0; j < len; j++) {
+     low  = (low  + buf[j]) % BASE;
+     high = (high + low) % BASE;
+   }
+   checksum = (high << 16) | low;
+
+   Both 16-bit halves of the checksum are between 0 and BASE-1 (inclusive).
+   Hence, the minimum possible checksum value is 0, and the maximum is
+   ((BASE-1) << 16) | (BASE-1).  Applications may have reserved values
+   outside this range to carry special meanings.
+
+   NOTE: If adler32() is changed in ANY way, be absolutely sure that the
+   change will NOT cause checksums previously stored to not match the data
+   they were originally intended to match, or expand the range in such a
+   way that values reserved by applications to carry special meanings now
+   become checksums of valid data.  Also, be sure to change adler32_range()
+   accordingly.
+
+   This explanation and adler32_range() are not part of original software
+   distribution.  They are added at Google (2006) in accordance with the
+   copyright notice in zlib.h, which permits alteration and redistribution
+   of the original software provided, among other things, that altered
+   source versions must be plainly marked as such and not misrepresented as
+   being the original software.  
+*/
+
+void ZEXPORT adler32_range(min, max)
+    uLong *min;
+    uLong *max;
+{
+    *min = 0L;
+    *max = ((BASE-1) << 16) | (BASE-1);
+}
+
+uLong ZEXPORT adler32(adler, buf, len)
+    uLong adler;
+    const Bytef *buf;
+    uInt len;
+{
+    unsigned long sum2;
+    unsigned n;
+
+    /* split Adler-32 into component sums */
+    sum2 = (adler >> 16) & 0xffff;
+    adler &= 0xffff;
+
+    /* in case user likes doing a byte at a time, keep it fast */
+    if (len == 1) {
+        adler += buf[0];
+        if (adler >= BASE)
+            adler -= BASE;
+        sum2 += adler;
+        if (sum2 >= BASE)
+            sum2 -= BASE;
+        return adler | (sum2 << 16);
+    }
+
+    /* initial Adler-32 value (deferred check for len == 1 speed) */
+    if (buf == Z_NULL)
+        return 1L;
+
+    /* in case short lengths are provided, keep it somewhat fast */
+    if (len < 16) {
+        while (len--) {
+            adler += *buf++;
+            sum2 += adler;
+        }
+        if (adler >= BASE)
+            adler -= BASE;
+        MOD4(sum2);             /* only added so many BASE's */
+        return adler | (sum2 << 16);
+    }
+
+    /* do length NMAX blocks -- requires just one modulo operation */
+    while (len >= NMAX) {
+        len -= NMAX;
+        n = NMAX / 16;          /* NMAX is divisible by 16 */
+        do {
+            DO16(buf);          /* 16 sums unrolled */
+            buf += 16;
+        } while (--n);
+        MOD(adler);
+        MOD(sum2);
+    }
+
+    /* do remaining bytes (less than NMAX, still just one modulo) */
+    if (len) {                  /* avoid modulos if none remaining */
+        while (len >= 16) {
+            len -= 16;
+            DO16(buf);
+            buf += 16;
+        }
+        while (len--) {
+            adler += *buf++;
+            sum2 += adler;
+        }
+        MOD(adler);
+        MOD(sum2);
+    }
+
+    /* return recombined sums */
+    return adler | (sum2 << 16);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT adler32_combine(adler1, adler2, len2)
+    uLong adler1;
+    uLong adler2;
+    z_off_t len2;
+{
+    unsigned long sum1;
+    unsigned long sum2;
+    unsigned rem;
+
+    /* the derivation of this formula is left as an exercise for the reader */
+    rem = (unsigned)(len2 % BASE);
+    sum1 = adler1 & 0xffff;
+    sum2 = rem * sum1;
+    MOD(sum2);
+    sum1 += (adler2 & 0xffff) + BASE - 1;
+    sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
+    if (sum1 >= BASE) sum1 -= BASE;
+    if (sum1 >= BASE) sum1 -= BASE;
+    if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1);
+    if (sum2 >= BASE) sum2 -= BASE;
+    return sum1 | (sum2 << 16);
+}
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/blockhash.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/blockhash.cc
new file mode 100644
index 0000000..f8beebf
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/blockhash.cc
@@ -0,0 +1,434 @@
+// Copyright 2006, 2008 Google Inc.
+// Authors: Chandra Chereddi, Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <config.h>
+#include "blockhash.h"
+#include "compile_assert.h"
+#include <stdint.h>  // uint32_t
+#include "logging.h"
+#include "rolling_hash.h"
+
+namespace open_vcdiff {
+
+typedef unsigned long uword_t;  // a machine word                         NOLINT
+
+BlockHash::BlockHash(const char* source_data,
+                     size_t source_size,
+                     int starting_offset)
+    : source_data_(source_data),
+      source_size_(source_size),
+      starting_offset_(starting_offset),
+      last_block_added_(-1) {
+}
+
+BlockHash::~BlockHash() { }
+
+// kBlockSize must be at least 2 to be meaningful.  Since it's a compile-time
+// constant, check its value at compile time rather than wasting CPU cycles
+// on runtime checks.
+COMPILE_ASSERT(BlockHash::kBlockSize >= 2, kBlockSize_must_be_at_least_2);
+
+// kBlockSize is required to be a power of 2 because multiplication
+// (n * kBlockSize), division (n / kBlockSize) and MOD (n % kBlockSize)
+// are commonly-used operations.  If kBlockSize is a compile-time
+// constant and a power of 2, the compiler can convert these three operations
+// into bit-shift (>> or <<) and bitwise-AND (&) operations, which are much
+// more efficient than executing full integer multiply, divide, or remainder
+// instructions.
+COMPILE_ASSERT((BlockHash::kBlockSize & (BlockHash::kBlockSize - 1)) == 0,
+               kBlockSize_must_be_a_power_of_2);
+
+bool BlockHash::Init(bool populate_hash_table) {
+  if (!hash_table_.empty() ||
+      !next_block_table_.empty() ||
+      !last_block_table_.empty()) {
+    LOG(DFATAL) << "Init() called twice for same BlockHash object" << LOG_ENDL;
+    return false;
+  }
+  const size_t table_size = CalcTableSize(source_size_);
+  if (table_size == 0) {
+    LOG(DFATAL) << "Error finding table size for source size " << source_size_
+                << LOG_ENDL;
+    return false;
+  }
+  hash_table_.resize(table_size, -1);
+  next_block_table_.resize(GetNumberOfBlocks(), -1);
+  last_block_table_.resize(GetNumberOfBlocks(), -1);
+  if (populate_hash_table) {
+    AddAllBlocks();
+  }
+  return true;
+}
+
+const BlockHash* BlockHash::CreateDictionaryHash(const char* dictionary_data,
+                                                 size_t dictionary_size) {
+  BlockHash* new_dictionary_hash = new BlockHash(dictionary_data,
+                                                 dictionary_size,
+                                                 0);
+  if (!new_dictionary_hash->Init(/* populate_hash_table = */ true)) {
+    delete new_dictionary_hash;
+    return NULL;
+  } else {
+    return new_dictionary_hash;
+  }
+}
+
+BlockHash* BlockHash::CreateTargetHash(const char* target_data,
+                                       size_t target_size,
+                                       size_t dictionary_size) {
+  BlockHash* new_target_hash = new BlockHash(target_data,
+                                             target_size,
+                                             static_cast<int>(dictionary_size));
+  if (!new_target_hash->Init(/* populate_hash_table = */ false)) {
+    delete new_target_hash;
+    return NULL;
+  } else {
+    return new_target_hash;
+  }
+}
+
+// Returns zero if an error occurs.
+const size_t BlockHash::CalcTableSize(const size_t dictionary_size) {
+  // Overallocate the hash table by making it the same size (in bytes)
+  // as the source data.  This is a trade-off between space and time:
+  // the empty entries in the hash table will reduce the
+  // probability of a hash collision to (sizeof(int) / kblockSize),
+  // and so save time comparing false matches.
+  const size_t min_size = (dictionary_size / sizeof(int)) + 1;  // NOLINT
+  size_t table_size = 1;
+  // Find the smallest power of 2 that is >= min_size, and assign
+  // that value to table_size.
+  while (table_size < min_size) {
+    table_size <<= 1;
+    // Guard against an infinite loop
+    if (table_size <= 0) {
+      LOG(DFATAL) << "Internal error: CalcTableSize(dictionary_size = "
+                  << dictionary_size
+                  << "): resulting table_size " << table_size
+                  << " is zero or negative" << LOG_ENDL;
+      return 0;
+    }
+  }
+  // Check size sanity
+  if ((table_size & (table_size - 1)) != 0) {
+    LOG(DFATAL) << "Internal error: CalcTableSize(dictionary_size = "
+                << dictionary_size
+                << "): resulting table_size " << table_size
+                << " is not a power of 2" << LOG_ENDL;
+    return 0;
+  }
+  // The loop above tries to find the smallest power of 2 that is >= min_size.
+  // That value must lie somewhere between min_size and (min_size * 2),
+  // except for the case (dictionary_size == 0, table_size == 1).
+  if ((dictionary_size > 0) && (table_size > (min_size * 2))) {
+    LOG(DFATAL) << "Internal error: CalcTableSize(dictionary_size = "
+                << dictionary_size
+                << "): resulting table_size " << table_size
+                << " is too large" << LOG_ENDL;
+    return 0;
+  }
+  return table_size;
+}
+
+// If the hash value is already available from the rolling hash,
+// call this function to save time.
+void BlockHash::AddBlock(uint32_t hash_value) {
+  if (hash_table_.empty()) {
+    LOG(DFATAL) << "BlockHash::AddBlock() called before BlockHash::Init()"
+                << LOG_ENDL;
+    return;
+  }
+  // The initial value of last_block_added_ is -1.
+  int block_number = last_block_added_ + 1;
+  const int total_blocks =
+      static_cast<int>(source_size_ / kBlockSize);  // round down
+  if (block_number >= total_blocks) {
+    LOG(DFATAL) << "BlockHash::AddBlock() called"
+                   " with block number " << block_number
+                << " that is past last block " << (total_blocks - 1)
+                << LOG_ENDL;
+    return;
+  }
+  if (next_block_table_[block_number] != -1) {
+    LOG(DFATAL) << "Internal error in BlockHash::AddBlock(): "
+                   "block number = " << block_number
+                << ", next block should be -1 but is "
+                << next_block_table_[block_number] << LOG_ENDL;
+    return;
+  }
+  const int hash_table_index = GetHashTableIndex(hash_value);
+  const int first_matching_block = hash_table_[hash_table_index];
+  if (first_matching_block < 0) {
+    // This is the first entry with this hash value
+    hash_table_[hash_table_index] = block_number;
+    last_block_table_[block_number] = block_number;
+  } else {
+    // Add this entry at the end of the chain of matching blocks
+    const int last_matching_block = last_block_table_[first_matching_block];
+    if (next_block_table_[last_matching_block] != -1) {
+      LOG(DFATAL) << "Internal error in BlockHash::AddBlock(): "
+                     "first matching block = " << first_matching_block
+                  << ", last matching block = " << last_matching_block
+                  << ", next block should be -1 but is "
+                  << next_block_table_[last_matching_block] << LOG_ENDL;
+      return;
+    }
+    next_block_table_[last_matching_block] = block_number;
+    last_block_table_[first_matching_block] = block_number;
+  }
+  last_block_added_ = block_number;
+}
+
+void BlockHash::AddAllBlocks() {
+  AddAllBlocksThroughIndex(static_cast<int>(source_size_));
+}
+
+void BlockHash::AddAllBlocksThroughIndex(int end_index) {
+  if (end_index > static_cast<int>(source_size_)) {
+    LOG(DFATAL) << "BlockHash::AddAllBlocksThroughIndex() called"
+                   " with index " << end_index
+                << " higher than end index  " << source_size_ << LOG_ENDL;
+    return;
+  }
+  const int last_index_added = last_block_added_ * kBlockSize;
+  if (end_index <= last_index_added) {
+    LOG(DFATAL) << "BlockHash::AddAllBlocksThroughIndex() called"
+                   " with index " << end_index
+                << " <= last index added ( " << last_index_added
+                << ")" << LOG_ENDL;
+    return;
+  }
+  int end_limit = end_index;
+  // Don't allow reading any indices at or past source_size_.
+  // The Hash function extends (kBlockSize - 1) bytes past the index,
+  // so leave a margin of that size.
+  int last_legal_hash_index = static_cast<int>(source_size() - kBlockSize);
+  if (end_limit > last_legal_hash_index) {
+    end_limit = last_legal_hash_index + 1;
+  }
+  const char* block_ptr = source_data() + NextIndexToAdd();
+  const char* const end_ptr = source_data() + end_limit;
+  while (block_ptr < end_ptr) {
+    AddBlock(RollingHash<kBlockSize>::Hash(block_ptr));
+    block_ptr += kBlockSize;
+  }
+}
+
+COMPILE_ASSERT((BlockHash::kBlockSize % sizeof(uword_t)) == 0,
+               kBlockSize_must_be_a_multiple_of_machine_word_size);
+
+// A recursive template to compare a fixed number
+// of (possibly unaligned) machine words starting
+// at addresses block1 and block2.  Returns true or false
+// depending on whether an exact match was found.
+template<int number_of_words>
+inline bool CompareWholeWordValues(const char* block1,
+                                   const char* block2) {
+  return CompareWholeWordValues<1>(block1, block2) &&
+         CompareWholeWordValues<number_of_words - 1>(block1 + sizeof(uword_t),
+                                                     block2 + sizeof(uword_t));
+}
+
+// The base of the recursive template: compare one pair of machine words.
+template<>
+inline bool CompareWholeWordValues<1>(const char* word1,
+                                      const char* word2) {
+  uword_t aligned_word1, aligned_word2;
+  memcpy(&aligned_word1, word1, sizeof(aligned_word1));
+  memcpy(&aligned_word2, word2, sizeof(aligned_word2));
+  return aligned_word1 == aligned_word2;
+}
+
+// Calling BlockContentsMatch is equivalent to the following memcmp call:
+//
+//     memcmp(block1, block2, BlockHash::kBlockSize);
+//
+// This function will only be called for two blocks whose hash values match.
+// For that reason, it is very likely that either the blocks are identical,
+// or they have different first bytes.  (Given a good hash function, if two
+// non-identical blocks have the same hash value, the probability that their
+// first bytes differ is the same as the probability of two random bytes
+// differing: 255/256, or rather smaller for text data.)  So optimize
+// for these two common cases.
+//
+// A block must be composed of an integral number of machine words
+// (uword_t values.)  This function takes advantage of that fact
+// by comparing the blocks as series of (possibly unaligned) word values.
+// A word-sized comparison can be performed as a single
+// machine instruction.  Comparing words instead of bytes means that,
+// on a 64-bit platform, this function will use 8 times fewer test-and-branch
+// instructions than a byte-by-byte comparison.  Even with the extra
+// cost of the calls to memcpy, this method is still at least twice as fast
+// as memcmp (measured using gcc on a 64-bit platform, with a block size
+// of 32.)  For blocks with identical contents (a common case), this method
+// is over six times faster than memcmp.
+inline bool BlockHash::BlockContentsMatchInline(const char* block1,
+                                                const char* block2) {
+  // Optimize for mismatch in first byte, as described above
+  if (*block1 != *block2) {
+    return false;
+  }
+  static const size_t kWordsPerBlock = BlockHash::kBlockSize / sizeof(uword_t);
+  return CompareWholeWordValues<kWordsPerBlock>(block1, block2);
+}
+
+bool BlockHash::BlockContentsMatch(const char* block1, const char* block2) {
+  return BlockContentsMatchInline(block1, block2);
+}
+
+inline int BlockHash::SkipNonMatchingBlocks(int block_number,
+                                            const char* block_ptr) const {
+  int probes = 0;
+  while ((block_number != -1) &&
+         !BlockContentsMatchInline(block_ptr,
+                                   &source_data_[block_number * kBlockSize])) {
+    if (++probes > kMaxProbes) {
+      return -1;  // Avoid too much chaining
+    }
+    block_number = next_block_table_[block_number];
+  }
+  return block_number;
+}
+
+// Init() must have been called and returned true before using
+// FirstMatchingBlock or NextMatchingBlock.  No check is performed
+// for this condition; the code will crash if this condition is violated.
+inline int BlockHash::FirstMatchingBlockInline(uint32_t hash_value,
+                                               const char* block_ptr) const {
+  return SkipNonMatchingBlocks(hash_table_[GetHashTableIndex(hash_value)],
+                               block_ptr);
+}
+
+int BlockHash::FirstMatchingBlock(uint32_t hash_value,
+                                  const char* block_ptr) const {
+  return FirstMatchingBlockInline(hash_value, block_ptr);
+}
+
+int BlockHash::NextMatchingBlock(int block_number,
+                                 const char* block_ptr) const {
+  if (static_cast<size_t>(block_number) >= GetNumberOfBlocks()) {
+    LOG(DFATAL) << "NextMatchingBlock called for invalid block number "
+                << block_number << LOG_ENDL;
+    return -1;
+  }
+  return SkipNonMatchingBlocks(next_block_table_[block_number], block_ptr);
+}
+
+// Keep a count of the number of matches found.  This will throttle the
+// number of iterations in FindBestMatch.  For example, if the entire
+// dictionary is made up of spaces (' ') and the search string is also
+// made up of spaces, there will be one match for each block in the
+// dictionary.
+inline bool BlockHash::TooManyMatches(int* match_counter) {
+  ++(*match_counter);
+  return (*match_counter) > kMaxMatchesToCheck;
+}
+
+// Returns the number of bytes to the left of source_match_start
+// that match the corresponding bytes to the left of target_match_start.
+// Will not examine more than max_bytes bytes, which is to say that
+// the return value will be in the range [0, max_bytes] inclusive.
+int BlockHash::MatchingBytesToLeft(const char* source_match_start,
+                                   const char* target_match_start,
+                                   int max_bytes) {
+  const char* source_ptr = source_match_start;
+  const char* target_ptr = target_match_start;
+  int bytes_found = 0;
+  while (bytes_found < max_bytes) {
+    --source_ptr;
+    --target_ptr;
+    if (*source_ptr != *target_ptr) {
+      break;
+    }
+    ++bytes_found;
+  }
+  return bytes_found;
+}
+
+// Returns the number of bytes starting at source_match_end
+// that match the corresponding bytes starting at target_match_end.
+// Will not examine more than max_bytes bytes, which is to say that
+// the return value will be in the range [0, max_bytes] inclusive.
+int BlockHash::MatchingBytesToRight(const char* source_match_end,
+                                    const char* target_match_end,
+                                    int max_bytes) {
+  const char* source_ptr = source_match_end;
+  const char* target_ptr = target_match_end;
+  int bytes_found = 0;
+  while ((bytes_found < max_bytes) && (*source_ptr == *target_ptr)) {
+    ++bytes_found;
+    ++source_ptr;
+    ++target_ptr;
+  }
+  return bytes_found;
+}
+
+// No NULL checks are performed on the pointer arguments.  The caller
+// must guarantee that none of the arguments is NULL, or a crash will occur.
+//
+// The vast majority of calls to FindBestMatch enter the loop *zero* times,
+// which is to say that most candidate blocks find no matches in the dictionary.
+// The important sections for optimization are therefore the code outside the
+// loop and the code within the loop conditions.  Keep this to a minimum.
+void BlockHash::FindBestMatch(uint32_t hash_value,
+                              const char* target_candidate_start,
+                              const char* target_start,
+                              size_t target_size,
+                              Match* best_match) const {
+  int match_counter = 0;
+  for (int block_number = FirstMatchingBlockInline(hash_value,
+                                                   target_candidate_start);
+       (block_number >= 0) && !TooManyMatches(&match_counter);
+       block_number = NextMatchingBlock(block_number, target_candidate_start)) {
+    int source_match_offset = block_number * kBlockSize;
+    const int source_match_end = source_match_offset + kBlockSize;
+
+    int target_match_offset =
+        static_cast<int>(target_candidate_start - target_start);
+    const int target_match_end = target_match_offset + kBlockSize;
+
+    size_t match_size = kBlockSize;
+    {
+      // Extend match start towards beginning of unencoded data
+      const int limit_bytes_to_left = std::min(source_match_offset,
+                                               target_match_offset);
+      const int matching_bytes_to_left =
+          MatchingBytesToLeft(source_data_ + source_match_offset,
+                              target_start + target_match_offset,
+                              limit_bytes_to_left);
+      source_match_offset -= matching_bytes_to_left;
+      target_match_offset -= matching_bytes_to_left;
+      match_size += matching_bytes_to_left;
+    }
+    {
+      // Extend match end towards end of unencoded data
+      const size_t source_bytes_to_right = source_size_ - source_match_end;
+      const size_t target_bytes_to_right = target_size - target_match_end;
+      const size_t limit_bytes_to_right = std::min(source_bytes_to_right,
+                                                   target_bytes_to_right);
+      match_size +=
+          MatchingBytesToRight(source_data_ + source_match_end,
+                               target_start + target_match_end,
+                               static_cast<int>(limit_bytes_to_right));
+    }
+    // Update in/out parameter if the best match found was better
+    // than any match already stored in *best_match.
+    best_match->ReplaceIfBetterMatch(match_size,
+                                     source_match_offset + starting_offset_,
+                                     target_match_offset);
+  }
+}
+
+}  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/blockhash.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/blockhash.h
new file mode 100644
index 0000000..ba15db8
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/blockhash.h
@@ -0,0 +1,494 @@
+// Copyright 2006 Google Inc.
+// Authors: Sanjay Ghemawat, Jeff Dean, Chandra Chereddi, Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Implementation of the Bentley/McIlroy algorithm for finding differences.
+// Bentley, McIlroy.  DCC 1999.  Data Compression Using Long Common Strings.
+// http://citeseer.ist.psu.edu/555557.html
+
+#ifndef OPEN_VCDIFF_BLOCKHASH_H_
+#define OPEN_VCDIFF_BLOCKHASH_H_
+
+#include <config.h>
+#include <stdint.h>  // uint32_t
+#include <cstddef>  // size_t
+#include <vector>
+
+namespace open_vcdiff {
+
+// A generic hash table which will be used to keep track of byte runs
+// of size kBlockSize in both the incrementally processed target data
+// and the preprocessed source dictionary.
+//
+// A custom hash table implementation is used instead of the standard
+// hash_map template because we know that there will be exactly one
+// entry in the BlockHash corresponding to each kBlockSize bytes
+// in the source data, which makes certain optimizations possible:
+// * The memory for the hash table and for all hash entries can be allocated
+//   in one step rather than incrementally for each insert operation.
+// * A single integer can be used to represent both
+//   the index of the next hash entry in the chain
+//   and the position of the entry within the source data
+//   (== kBlockSize * block_number).  This greatly reduces the size
+//   of a hash entry.
+//
+class BlockHash {
+ public:
+  // Block size as per Bentley/McIlroy; must be a power of two.
+  //
+  // Using (for example) kBlockSize = 4 guarantees that no match smaller
+  // than size 4 will be identified, that some matches having sizes
+  // 4, 5, or 6 may be identified, and that all matches
+  // having size 7 or greater will be identified (because any string of
+  // 7 bytes must contain a complete aligned block of 4 bytes.)
+  //
+  // Increasing kBlockSize by a factor of two will halve the amount of
+  // memory needed for the next block table, and will halve the setup time
+  // for a new BlockHash.  However, it also doubles the minimum
+  // match length that is guaranteed to be found in FindBestMatch(),
+  // so that function will be less effective in finding matches.
+  //
+  // Computational effort in FindBestMatch (which is the inner loop of
+  // the encoding algorithm) will be proportional to the number of
+  // matches found, and a low value of kBlockSize will waste time
+  // tracking down small matches.  On the other hand, if this value
+  // is set too high, no matches will be found at all.
+  //
+  // It is suggested that different values of kBlockSize be tried against
+  // a representative data set to find the best tradeoff between
+  // memory/CPU and the effectiveness of FindBestMatch().
+  //
+  // If you change kBlockSize to a smaller value, please increase
+  // kMaxMatchesToCheck accordingly.
+  static const int kBlockSize = 32;
+
+  // This class is used to store the best match found by FindBestMatch()
+  // and return it to the caller.
+  class Match {
+   public:
+    Match() : size_(0), source_offset_(-1), target_offset_(-1) { }
+
+    void ReplaceIfBetterMatch(size_t candidate_size,
+                              int candidate_source_offset,
+                              int candidate_target_offset) {
+      if (candidate_size > size_) {
+        size_ = candidate_size;
+        source_offset_ = candidate_source_offset;
+        target_offset_ = candidate_target_offset;
+      }
+    }
+
+    size_t size() const { return size_; }
+    int source_offset() const { return source_offset_; }
+    int target_offset() const { return target_offset_; }
+
+   private:
+     // The size of the best (longest) match passed to ReplaceIfBetterMatch().
+    size_t size_;
+
+    // The source offset of the match, including the starting_offset_
+    // of the BlockHash for which the match was found.
+    int source_offset_;
+
+    // The target offset of the match.  An offset of 0 corresponds to the
+    // data at target_start, which is an argument of FindBestMatch().
+    int target_offset_;
+
+    // Making these private avoids implicit copy constructor
+    // & assignment operator
+    Match(const Match&);  // NOLINT
+    void operator=(const Match&);
+  };
+
+  // A BlockHash is created using a buffer of source data.  The hash table
+  // will contain one entry for each kBlockSize-byte block in the
+  // source data.
+  //
+  // See the comments for starting_offset_, below, for a description of
+  // the starting_offset argument.  For a hash of source (dictionary) data,
+  // starting_offset_ will be zero; for a hash of previously encoded
+  // target data, starting_offset_ will be equal to the dictionary size.
+  //
+  BlockHash(const char* source_data, size_t source_size, int starting_offset);
+
+  ~BlockHash();
+
+  // Initializes the object before use.
+  // This method must be called after constructing a BlockHash object,
+  // and before any other method may be called.  This is because
+  // Init() dynamically allocates hash_table_ and next_block_table_.
+  // Returns true if initialization succeeded, or false if an error occurred,
+  // in which case no other method except the destructor may then be used
+  // on the object.
+  //
+  // If populate_hash_table is true, then AddAllBlocks() will be called
+  // to populate the hash table.  If populate_hash_table is false, then
+  // classes that inherit from BlockHash are expected to call AddBlock()
+  // to incrementally populate individual blocks of data.
+  //
+  bool Init(bool populate_hash_table);
+
+  // In the context of the open-vcdiff encoder, BlockHash is used for two
+  // purposes: to hash the source (dictionary) data, and to hash
+  // the previously encoded target data.  The main differences between
+  // a dictionary BlockHash and a target BlockHash are as follows:
+  //
+  //   1. The best_match->source_offset() returned from FindBestMatch()
+  //      for a target BlockHash is computed in the following manner:
+  //      the starting offset of the first byte in the target data
+  //      is equal to the dictionary size.  FindBestMatch() will add
+  //      starting_offset_ to any best_match->source_offset() value it returns,
+  //      in order to produce the correct offset value for a target BlockHash.
+  //   2. For a dictionary BlockHash, the entire data set is hashed at once
+  //      when Init() is called with the parameter populate_hash_table = true.
+  //      For a target BlockHash, because the previously encoded target data
+  //      includes only the data seen up to the current encoding position,
+  //      the data blocks are hashed incrementally as the encoding position
+  //      advances, using AddOneIndexHash() and AddAllBlocksThroughIndex().
+  //
+  // The following two factory functions can be used to create BlockHash
+  // objects for each of these two purposes.  Each factory function calls
+  // the object constructor and also calls Init().  If an error occurs,
+  // NULL is returned; otherwise a valid BlockHash object is returned.
+  // Since a dictionary BlockHash is not expected to be modified after
+  // initialization, a const object is returned.
+  // The caller is responsible for deleting the returned object
+  // (using the C++ delete operator) once it is no longer needed.
+  static const BlockHash* CreateDictionaryHash(const char* dictionary_data,
+                                               size_t dictionary_size);
+  static BlockHash* CreateTargetHash(const char* target_data,
+                                     size_t target_size,
+                                     size_t dictionary_size);
+
+  const size_t table_size() const { return hash_table_.size(); }
+  const int starting_offset() const { return starting_offset_; }
+
+  // This function will be called to add blocks incrementally to the target hash
+  // as the encoding position advances through the target data.  It will be
+  // called for every kBlockSize-byte block in the target data, regardless
+  // of whether the block is aligned evenly on a block boundary.  The
+  // BlockHash will only store hash entries for the evenly-aligned blocks.
+  //
+  void AddOneIndexHash(int index, uint32_t hash_value) {
+    if (index == NextIndexToAdd()) {
+      AddBlock(hash_value);
+    }
+  }
+
+  // Calls AddBlock() for each kBlockSize-byte block in the range
+  // (last_block_added_ * kBlockSize, end_index), exclusive of the endpoints.
+  // If end_index <= the last index added (last_block_added_ * kBlockSize),
+  // this function does nothing.
+  //
+  // A partial block beginning anywhere up to (end_index - 1) is also added,
+  // unless it extends outside the end of the source data.  Like AddAllBlocks(),
+  // this function computes the hash value for each of the blocks in question
+  // from scratch, so it is not a good option if the hash values have already
+  // been computed for some other purpose.
+  //
+  // Example: assume kBlockSize = 4, last_block_added_ = 1, and there are
+  // 14 bytes of source data.
+  // If AddAllBlocksThroughIndex(9) is invoked, then it will call AddBlock()
+  // only for block number 2 (at index 8).
+  // If, after that, AddAllBlocksThroughIndex(14) is invoked, it will not call
+  // AddBlock() at all, because block 3 (beginning at index 12) would
+  // fall outside the range of source data.
+  //
+  // VCDiffEngine::Encode (in vcdiffengine.cc) uses this function to
+  // add a whole range of data to a target hash when a COPY instruction
+  // is generated.
+  void AddAllBlocksThroughIndex(int end_index);
+
+  // FindBestMatch takes a position within the unencoded target data
+  // (target_candidate_start) and the hash value of the kBlockSize bytes
+  // beginning at that position (hash_value).  It attempts to find a matching
+  // set of bytes within the source (== dictionary) data, expanding
+  // the match both below and above the target block.  It cannot expand
+  // the match outside the bounds of the source data, or below
+  // target_start within the target data, or past
+  // the end limit of (target_start + target_length).
+  //
+  // target_candidate_start is the start of the candidate block within the
+  // target data for which a match will be sought, while
+  // target_start (which is <= target_candidate_start)
+  // is the start of the target data that has yet to be encoded.
+  //
+  // If a match is found whose size is greater than the size
+  // of best_match, this function populates *best_match with the
+  // size, source_offset, and target_offset of the match found.
+  // best_match->source_offset() will contain the index of the start of the
+  // matching source data, plus starting_offset_
+  // (see description of starting_offset_ for details);
+  // best_match->target_offset() will contain the offset of the match
+  // beginning with target_start = offset 0, such that
+  //     0 <= best_match->target_offset()
+  //              <= (target_candidate_start - target_start);
+  // and best_match->size() will contain the size of the match.
+  // If no such match is found, this function leaves *best_match unmodified.
+  //
+  // On calling FindBestMatch(), best_match must
+  // point to a valid Match object, and cannot be NULL.
+  // The same Match object can be passed
+  // when calling FindBestMatch() on a different BlockHash object
+  // for the same candidate data block, in order to find
+  // the best match possible across both objects.  For example:
+  //
+  //     open_vcdiff::BlockHash::Match best_match;
+  //     uint32_t hash_value =
+  //         RollingHash<BlockHash::kBlockSize>::Hash(target_candidate_start);
+  //     bh1.FindBestMatch(hash_value,
+  //                       target_candidate_start,
+  //                       target_start,
+  //                       target_length,
+  //                       &best_match);
+  //     bh2.FindBestMatch(hash_value,
+  //                       target_candidate_start,
+  //                       target_start,
+  //                       target_length,
+  //                       &best_match);
+  //     if (best_size >= 0) {
+  //       // a match was found; its size, source offset, and target offset
+  //       // can be found in best_match
+  //     }
+  //
+  // hash_value is passed as a separate parameter from target_candidate_start,
+  // (rather than calculated within FindBestMatch) in order to take
+  // advantage of the rolling hash, which quickly calculates the hash value
+  // of the block starting at target_candidate_start based on
+  // the known hash value of the block starting at (target_candidate_start - 1).
+  // See vcdiffengine.cc for more details.
+  //
+  // Example:
+  //    kBlockSize: 4
+  //    target text: "ANDREW LLOYD WEBBER"
+  //                 1^    5^2^         3^
+  //    dictionary: "INSURANCE : LLOYDS OF LONDON"
+  //                           4^
+  //    hashed dictionary blocks:
+  //        "INSU", "RANC", "E : ", "LLOY", "DS O", "F LON"
+  //
+  //    1: target_start (beginning of unencoded data)
+  //    2: target_candidate_start (for the block "LLOY")
+  //    3: target_length (points one byte beyond the last byte of data.)
+  //    4: best_match->source_offset() (after calling FindBestMatch)
+  //    5: best_match->target_offset() (after calling FindBestMatch)
+  //
+  //    Under these conditions, FindBestMatch will find a matching
+  //    hashed dictionary block for "LLOY", and will extend the beginning of
+  //    this match backwards by one byte, and the end of the match forwards
+  //    by one byte, finding that the best match is " LLOYD"
+  //    with best_match->source_offset() = 10
+  //                                  (offset of " LLOYD" in the source string),
+  //         best_match->target_offset() = 6
+  //                                  (offset of " LLOYD" in the target string),
+  //     and best_match->size() = 6.
+  //
+  void FindBestMatch(uint32_t hash_value,
+                     const char* target_candidate_start,
+                     const char* target_start,
+                     size_t target_size,
+                     Match* best_match) const;
+
+ protected:
+  // FindBestMatch() will not process more than this number
+  // of matching hash entries.
+  //
+  // It is necessary to have a limit on the maximum number of matches
+  // that will be checked in order to avoid the worst-case performance
+  // possible if, for example, all the blocks in the dictionary have
+  // the same hash value.  See the unit test SearchStringFindsTooManyMatches
+  // for an example of such a case.  The encoder uses a loop in
+  // VCDiffEngine::Encode over each target byte, containing a loop in
+  // BlockHash::FindBestMatch over the number of matches (up to a maximum
+  // of the number of source blocks), containing two loops that extend
+  // the match forwards and backwards up to the number of source bytes.
+  // Total complexity in the worst case is
+  //     O([target size] * source_size_ * source_size_
+  // Placing a limit on the possible number of matches checked changes this to
+  //     O([target size] * source_size_ * kMaxMatchesToCheck)
+  //
+  // In empirical testing on real HTML text, using a block size of 4,
+  // the number of true matches per call to FindBestMatch() did not exceed 78;
+  // with a block size of 32, the number of matches did not exceed 3.
+  //
+  // The expected number of true matches scales super-linearly
+  // with the inverse of kBlockSize, but here a linear scale is used
+  // for block sizes smaller than 32.
+  static const int kMaxMatchesToCheck = (kBlockSize >= 32) ? 8 :
+                                            (8 * (32 / kBlockSize));
+
+  // Do not skip more than this number of non-matching hash collisions
+  // to find the next matching entry in the hash chain.
+  static const int kMaxProbes = 16;
+
+  // Internal routine which calculates a hash table size based on kBlockSize and
+  // the dictionary_size.  Will return a power of two if successful, or 0 if an
+  // internal error occurs.  Some calculations (such as GetHashTableIndex())
+  // depend on the table size being a power of two.
+  static const size_t CalcTableSize(const size_t dictionary_size);
+
+  const size_t GetNumberOfBlocks() const {
+    return source_size_ / kBlockSize;
+  }
+
+  // Use the lowest-order bits of the hash value
+  // as the index into the hash table.
+  int GetHashTableIndex(uint32_t hash_value) const {
+    return hash_value & (table_size() - 1);
+  }
+
+  // The index within source_data_ of the next block
+  // for which AddBlock() should be called.
+  int NextIndexToAdd() const {
+    return (last_block_added_ + 1) * kBlockSize;
+  }
+
+  static inline bool TooManyMatches(int* match_counter);
+
+  const char* const source_data() { return source_data_; }
+  const size_t source_size() { return source_size_; }
+
+  // Adds an entry to the hash table for one block of source data of length
+  // kBlockSize, starting at source_data_[block_number * kBlockSize],
+  // where block_number is always (last_block_added_ + 1).  That is,
+  // AddBlock() must be called once for each block in source_data_
+  // in increasing order.
+  void AddBlock(uint32_t hash_value);
+
+  // Calls AddBlock() for each complete kBlockSize-byte block between
+  // source_data_ and (source_data_ + source_size_).  It is equivalent
+  // to calling AddAllBlocksThroughIndex(source_data + source_size).
+  // This function is called when Init(true) is invoked.
+  void AddAllBlocks();
+
+  // Returns true if the contents of the kBlockSize-byte block
+  // beginning at block1 are identical to the contents of
+  // the block beginning at block2; false otherwise.
+  static bool BlockContentsMatch(const char* block1, const char* block2);
+
+  // Finds the first block number within the hashed data
+  // that represents a match for the given hash value.
+  // Returns -1 if no match was found.
+  //
+  // Init() must have been called and returned true before using
+  // FirstMatchingBlock or NextMatchingBlock.  No check is performed
+  // for this condition; the code will crash if this condition is violated.
+  //
+  // The hash table is initially populated with -1 (not found) values,
+  // so if this function is called before the hash table has been populated
+  // using AddAllBlocks() or AddBlock(), it will simply return -1
+  // for any value of hash_value.
+  int FirstMatchingBlock(uint32_t hash_value, const char* block_ptr) const;
+
+  // Given a block number returned by FirstMatchingBlock()
+  // or by a previous call to NextMatchingBlock(), returns
+  // the next block number that matches the same hash value.
+  // Returns -1 if no match was found.
+  int NextMatchingBlock(int block_number, const char* block_ptr) const;
+
+  // Inline versions of BlockContentsMatch and FirstMatchingBlock.
+  // These save the cost of a function call
+  // when these routines are called from within the module.
+  // The external (non-inlined) versions are called only by unit tests.
+  static inline bool BlockContentsMatchInline(const char* block1,
+                                              const char* block2);
+  inline int FirstMatchingBlockInline(uint32_t hash_value,
+                                      const char* block_ptr) const;
+
+  // Walk through the hash entry chain, skipping over any false matches
+  // (for which the lowest bits of the fingerprints match,
+  // but the actual block data does not.)  Returns the block number of
+  // the first true match found, or -1 if no true match was found.
+  // If block_number is a matching block, the function will return block_number
+  // without skipping to the next block.
+  int SkipNonMatchingBlocks(int block_number, const char* block_ptr) const;
+
+  // Returns the number of bytes to the left of source_match_start
+  // that match the corresponding bytes to the left of target_match_start.
+  // Will not examine more than max_bytes bytes, which is to say that
+  // the return value will be in the range [0, max_bytes] inclusive.
+  static int MatchingBytesToLeft(const char* source_match_start,
+                                 const char* target_match_start,
+                                 int max_bytes);
+
+  // Returns the number of bytes starting at source_match_end
+  // that match the corresponding bytes starting at target_match_end.
+  // Will not examine more than max_bytes bytes, which is to say that
+  // the return value will be in the range [0, max_bytes] inclusive.
+  static int MatchingBytesToRight(const char* source_match_end,
+                                  const char* target_match_end,
+                                  int max_bytes);
+
+  // The protected functions BlockContentsMatch, FirstMatchingBlock,
+  // NextMatchingBlock, MatchingBytesToLeft, and MatchingBytesToRight
+  // should be made accessible to unit tests.
+  friend class BlockHashTest;
+
+ private:
+  const char* const  source_data_;
+  const size_t       source_size_;
+
+  // The size of this array is determined using CalcTableSize().  It has at
+  // least one element for each kBlockSize-byte block in the source data.
+  // GetHashTableIndex() returns an index into this table for a given hash
+  // value.  The value of each element of hash_table_ is the lowest block
+  // number in the source data whose hash value would return the same value from
+  // GetHashTableIndex(), or -1 if there is no matching block.  This value can
+  // then be used as an index into next_block_table_ to retrieve the entire set
+  // of matching block numbers.
+  std::vector<int> hash_table_;
+
+  // An array containing one element for each source block.  Each element is
+  // either -1 (== not found) or the index of the next block whose hash value
+  // would produce a matching result from GetHashTableIndex().
+  std::vector<int> next_block_table_;
+
+  // This array has the same size as hash_table_.  For every block number B that
+  // is referenced in hash_table_, last_block_table_[B] will contain the maximum
+  // block number among all blocks that have the same GetHashTableIndex() value
+  // as the block B.  This number may be B itself.  For a block number B' that
+  // is not referenced in hash_table_, the value of last_block_table_[B'] is -1.
+  // This table is used only while populating the hash table, not while looking
+  // up hash values in the table.  Keeping track of the last block number in the
+  // chain allows us to construct the block chains as FIFO rather than LIFO
+  // lists, so that the match with the lowest index is returned first.  This
+  // should result in a more compact encoding because the VCDIFF format favors
+  // smaller index values and repeated index values.
+  std::vector<int> last_block_table_;
+
+  // The offset of the first byte of source data (the data at source_data_[0]).
+  // For the purpose of computing offsets, the source data and target data
+  // are considered to be concatenated -- not literally in a single memory
+  // buffer, but conceptually as described in the RFC.
+  // The first byte of the previously encoded target data
+  // has an offset that is equal to dictionary_size, i.e., just after
+  // the last byte of source data.
+  // For a hash of source (dictionary) data, starting_offset_ will be zero;
+  // for a hash of previously encoded target data, starting_offset_ will be
+  // equal to the dictionary size.
+  const int starting_offset_;
+
+  // The last index added by AddBlock().  This determines the block number
+  // for successive calls to AddBlock(), and is also
+  // used to determine the starting block for AddAllBlocksThroughIndex().
+  int last_block_added_;
+
+  // Making these private avoids implicit copy constructor & assignment operator
+  BlockHash(const BlockHash&);  // NOLINT
+  void operator=(const BlockHash&);
+};
+
+}  // namespace open_vcdiff
+
+#endif  // OPEN_VCDIFF_BLOCKHASH_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/blockhash_test.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/blockhash_test.cc
new file mode 100644
index 0000000..3f5808c
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/blockhash_test.cc
@@ -0,0 +1,896 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <config.h>
+#include "blockhash.h"
+#include <climits>  // INT_MIN
+#include <memory>  // auto_ptr
+#include "encodetable.h"
+#include "logging.h"
+#include "rolling_hash.h"
+#include "testing.h"
+
+namespace open_vcdiff {
+
+const int kBlockSize = BlockHash::kBlockSize;
+
+class BlockHashTest : public testing::Test {
+ protected:
+  static const int kTimingTestSize = 1 << 21;  // 2M
+  static const int kTimingTestIterations = 32;
+
+  BlockHashTest() {
+    dh_.reset(BlockHash::CreateDictionaryHash(sample_text,
+                                              strlen(sample_text)));
+    th_.reset(BlockHash::CreateTargetHash(sample_text, strlen(sample_text), 0));
+    EXPECT_TRUE(dh_.get() != NULL);
+    EXPECT_TRUE(th_.get() != NULL);
+  }
+
+  // BlockHashTest is a friend to BlockHash.  Expose the protected functions
+  // that will be tested by the children of BlockHashTest.
+  static bool BlockContentsMatch(const char* block1, const char* block2) {
+    return BlockHash::BlockContentsMatch(block1, block2);
+  }
+
+  int FirstMatchingBlock(const BlockHash& block_hash,
+                         uint32_t hash_value,
+                         const char* block_ptr) const {
+    return block_hash.FirstMatchingBlock(hash_value, block_ptr);
+  }
+
+  int NextMatchingBlock(const BlockHash& block_hash,
+                        int block_number,
+                        const char* block_ptr) const {
+    return block_hash.NextMatchingBlock(block_number, block_ptr);
+  }
+
+  static int MatchingBytesToLeft(const char* source_match_start,
+                                 const char* target_match_start,
+                                 int max_bytes) {
+    return BlockHash::MatchingBytesToLeft(source_match_start,
+                                          target_match_start,
+                                          max_bytes);
+  }
+
+  static int MatchingBytesToRight(const char* source_match_end,
+                                  const char* target_match_end,
+                                  int max_bytes) {
+    return BlockHash::MatchingBytesToRight(source_match_end,
+                                           target_match_end,
+                                           max_bytes);
+  }
+
+  static int StringLengthAsInt(const char* s) {
+    return static_cast<int>(strlen(s));
+  }
+
+  void InitBlocksToDifferAtNthByte(int n) {
+    CHECK(n < kBlockSize);
+    memset(compare_buffer_1_, 0xBE, kTimingTestSize);
+    memset(compare_buffer_2_, 0xBE, kTimingTestSize);
+    for (int index = n; index < kTimingTestSize; index += kBlockSize) {
+      compare_buffer_1_[index] = 0x00;
+      compare_buffer_2_[index] = 0x01;
+    }
+  }
+
+  void TestAndPrintTimesForCompareFunctions(bool should_be_identical) {
+    CHECK(compare_buffer_1_ != NULL);
+    CHECK(compare_buffer_2_ != NULL);
+    // Prime the memory cache.
+    prime_result_ =
+        memcmp(compare_buffer_1_, compare_buffer_2_, kTimingTestSize);
+    const char* const block1_limit =
+        &compare_buffer_1_[kTimingTestSize - kBlockSize];
+    int memcmp_result = 0;
+    CycleTimer memcmp_timer;
+    memcmp_timer.Start();
+    for (int i = 0; i < kTimingTestIterations; ++i) {
+      const char* block1 = compare_buffer_1_;
+      const char* block2 = compare_buffer_2_;
+      while (block1 < block1_limit) {
+        if (memcmp(block1, block2, kBlockSize) != 0) {
+          ++memcmp_result;
+        }
+        block1 += kBlockSize;
+        block2 += kBlockSize;
+      }
+    }
+    memcmp_timer.Stop();
+    double time_for_memcmp = static_cast<double>(memcmp_timer.GetInUsec())
+        / (kTimingTestSize * kTimingTestIterations);
+    int block_contents_match_result = 0;
+    CycleTimer block_contents_match_timer;
+    block_contents_match_timer.Start();
+    for (int i = 0; i < kTimingTestIterations; ++i) {
+      const char* block1 = compare_buffer_1_;
+      const char* block2 = compare_buffer_2_;
+      while (block1 < block1_limit) {
+        if (!BlockHash::BlockContentsMatch(block1, block2)) {
+          ++block_contents_match_result;
+        }
+        block1 += kBlockSize;
+        block2 += kBlockSize;
+      }
+    }
+    block_contents_match_timer.Stop();
+    double time_for_block_contents_match =
+        static_cast<double>(block_contents_match_timer.GetInUsec())
+        / (kTimingTestSize * kTimingTestIterations);
+    EXPECT_EQ(block_contents_match_result, memcmp_result);
+    if (should_be_identical) {
+      CHECK_EQ(0, memcmp_result);
+    } else {
+      CHECK_GT(memcmp_result, 0);
+    }
+    LOG(INFO) << "memcmp: " << time_for_memcmp << " us per operation"
+              << LOG_ENDL;
+    LOG(INFO) << "BlockHash::BlockContentsMatch: "
+              << time_for_block_contents_match << " us per operation"
+              << LOG_ENDL;
+    if (time_for_memcmp > 0) {
+      LOG(INFO) << "% change: "
+                << (((time_for_block_contents_match - time_for_memcmp)
+                       / time_for_memcmp) * 100.0) << "%" << LOG_ENDL;
+    }
+#ifdef NDEBUG
+    // Only check timings for optimized build
+    const double error_margin = 0.05;
+    EXPECT_GT(time_for_memcmp * (1.0 + error_margin),
+              time_for_block_contents_match);
+#endif  // NDEBUG
+  }
+
+  void TimingTestForBlocksThatDifferAtByte(int n) {
+    InitBlocksToDifferAtNthByte(n);
+    LOG(INFO) << "Comparing blocks that differ at byte " << n << LOG_ENDL;
+    TestAndPrintTimesForCompareFunctions(false);
+  }
+
+  // Copy sample_text_without_spaces and search_string_without_spaces
+  // into newly allocated sample_text and search_string buffers,
+  // but pad them with space characters so that every character
+  // in sample_text_without_spaces matches (kBlockSize - 1)
+  // space characters in sample_text, followed by that character.
+  // For example:
+  // Since sample_text_without_spaces begins "The only thing"...,
+  // if kBlockSize is 4, then 3 space characters will be inserted
+  // between each letter of sample_text, as follows:
+  // "   T   h   e       o   n   l   y       t   h   i   n   g"...
+  // This makes testing simpler, because finding a kBlockSize-byte match
+  // between the sample text and search string only depends on the
+  // trailing letter in each block.
+  static void MakeEachLetterABlock(const char* string_without_spaces,
+                                   const char** result) {
+    const size_t length_without_spaces = strlen(string_without_spaces);
+    char* padded_text = new char[(kBlockSize * length_without_spaces) + 1];
+    memset(padded_text, ' ', kBlockSize * length_without_spaces);
+    char* padded_text_ptr = padded_text + (kBlockSize - 1);
+    for (size_t i = 0; i < length_without_spaces; ++i) {
+      *padded_text_ptr = string_without_spaces[i];
+      padded_text_ptr += kBlockSize;
+    }
+    padded_text[kBlockSize * length_without_spaces] = '\0';
+    *result = padded_text;
+  }
+
+  static void SetUpTestCase() {
+    MakeEachLetterABlock(sample_text_without_spaces, &sample_text);
+    MakeEachLetterABlock(search_string_without_spaces, &search_string);
+    MakeEachLetterABlock(search_string_altered_without_spaces,
+                         &search_string_altered);
+    MakeEachLetterABlock(search_to_end_without_spaces, &search_to_end_string);
+    MakeEachLetterABlock(search_to_beginning_without_spaces,
+                         &search_to_beginning_string);
+    MakeEachLetterABlock(sample_text_many_matches_without_spaces,
+                         &sample_text_many_matches);
+    MakeEachLetterABlock(search_string_many_matches_without_spaces,
+                         &search_string_many_matches);
+    MakeEachLetterABlock("y", &test_string_y);
+    MakeEachLetterABlock("e", &test_string_e);
+    char* new_test_string_unaligned_e = new char[kBlockSize];
+    memset(new_test_string_unaligned_e, ' ', kBlockSize);
+    new_test_string_unaligned_e[kBlockSize - 2] = 'e';
+    test_string_unaligned_e = new_test_string_unaligned_e;
+    char* new_test_string_all_Qs = new char[kBlockSize];
+    memset(new_test_string_all_Qs, 'Q', kBlockSize);
+    test_string_all_Qs = new_test_string_all_Qs;
+    hashed_y = RollingHash<kBlockSize>::Hash(test_string_y);
+    hashed_e = RollingHash<kBlockSize>::Hash(test_string_e);
+    hashed_f =
+        RollingHash<kBlockSize>::Hash(&search_string[index_of_f_in_fearsome]);
+    hashed_unaligned_e = RollingHash<kBlockSize>::Hash(test_string_unaligned_e);
+    hashed_all_Qs = RollingHash<kBlockSize>::Hash(test_string_all_Qs);
+  }
+
+  static void TearDownTestCase() {
+    delete[] sample_text;
+    delete[] search_string;
+    delete[] search_string_altered;
+    delete[] search_to_end_string;
+    delete[] search_to_beginning_string;
+    delete[] sample_text_many_matches;
+    delete[] search_string_many_matches;
+    delete[] test_string_y;
+    delete[] test_string_e;
+    delete[] test_string_unaligned_e;
+    delete[] test_string_all_Qs;
+  }
+
+  // Each block in the sample text and search string is kBlockSize bytes long,
+  // and consists of (kBlockSize - 1) space characters
+  // followed by a single letter of text.
+
+  // Block numbers of certain characters within the sample text:
+  // All six occurrences of "e", in order.
+  static const int block_of_first_e = 2;
+  static const int block_of_second_e = 16;
+  static const int block_of_third_e = 21;
+  static const int block_of_fourth_e = 27;
+  static const int block_of_fifth_e = 35;
+  static const int block_of_sixth_e = 42;
+
+  static const int block_of_y_in_only = 7;
+  // The block number is multiplied by kBlockSize to arrive at the
+  // index, which points to the (kBlockSize - 1) space characters before
+  // the letter specified.
+  // Indices of certain characters within the sample text.
+  static const int index_of_first_e = block_of_first_e * kBlockSize;
+  static const int index_of_fourth_e = block_of_fourth_e * kBlockSize;
+  static const int index_of_sixth_e = block_of_sixth_e * kBlockSize;
+  static const int index_of_y_in_only = block_of_y_in_only * kBlockSize;
+  static const int index_of_space_before_fear_is_fear = 25 * kBlockSize;
+  static const int index_of_longest_match_ear_is_fear = 27 * kBlockSize;
+  static const int index_of_i_in_fear_is_fear = 31 * kBlockSize;
+  static const int index_of_space_before_fear_itself = 33 * kBlockSize;
+  static const int index_of_space_before_itself = 38 * kBlockSize;
+  static const int index_of_ababc = 4 * kBlockSize;
+
+  // Indices of certain characters within the search strings.
+  static const int index_of_second_w_in_what_we = 5 * kBlockSize;
+  static const int index_of_second_e_in_what_we_hear = 9 * kBlockSize;
+  static const int index_of_f_in_fearsome = 16 * kBlockSize;
+  static const int index_of_space_in_eat_itself =  12 * kBlockSize;
+  static const int index_of_i_in_itself = 13 * kBlockSize;
+  static const int index_of_t_in_use_the = 4 * kBlockSize;
+  static const int index_of_o_in_online = 8 * kBlockSize;
+
+  static const char sample_text_without_spaces[];
+  static const char search_string_without_spaces[];
+  static const char search_string_altered_without_spaces[];
+  static const char search_to_end_without_spaces[];
+  static const char search_to_beginning_without_spaces[];
+  static const char sample_text_many_matches_without_spaces[];
+  static const char search_string_many_matches_without_spaces[];
+
+  static const char* sample_text;
+  static const char* search_string;
+  static const char* search_string_altered;
+  static const char* search_to_end_string;
+  static const char* search_to_beginning_string;
+  static const char* sample_text_many_matches;
+  static const char* search_string_many_matches;
+
+  static const char* test_string_y;
+  static const char* test_string_e;
+  static const char* test_string_all_Qs;
+  static const char* test_string_unaligned_e;
+
+  static uint32_t hashed_y;
+  static uint32_t hashed_e;
+  static uint32_t hashed_f;
+  static uint32_t hashed_unaligned_e;
+  static uint32_t hashed_all_Qs;
+
+  // Boost scoped_ptr, if available, could be used instead of std::auto_ptr.
+  std::auto_ptr<const BlockHash> dh_;  // hash table is populated at startup
+  std::auto_ptr<BlockHash> th_;  // hash table not populated;
+                                // used to test incremental adds
+
+  BlockHash::Match best_match_;
+  char* compare_buffer_1_;
+  char* compare_buffer_2_;
+  int prime_result_;
+};
+
+#ifdef GTEST_HAS_DEATH_TEST
+typedef BlockHashTest BlockHashDeathTest;
+#endif  // GTEST_HAS_DEATH_TEST
+
+// The C++ standard requires a separate definition of these static const values,
+// even though their initializers are given within the class definition.
+const int BlockHashTest::block_of_first_e;
+const int BlockHashTest::block_of_second_e;
+const int BlockHashTest::block_of_third_e;
+const int BlockHashTest::block_of_fourth_e;
+const int BlockHashTest::block_of_fifth_e;
+const int BlockHashTest::block_of_sixth_e;
+const int BlockHashTest::block_of_y_in_only;
+const int BlockHashTest::index_of_first_e;
+const int BlockHashTest::index_of_fourth_e;
+const int BlockHashTest::index_of_sixth_e;
+const int BlockHashTest::index_of_y_in_only;
+const int BlockHashTest::index_of_space_before_fear_is_fear;
+const int BlockHashTest::index_of_longest_match_ear_is_fear;
+const int BlockHashTest::index_of_i_in_fear_is_fear;
+const int BlockHashTest::index_of_space_before_fear_itself;
+const int BlockHashTest::index_of_space_before_itself;
+const int BlockHashTest::index_of_ababc;
+const int BlockHashTest::index_of_second_w_in_what_we;
+const int BlockHashTest::index_of_second_e_in_what_we_hear;
+const int BlockHashTest::index_of_f_in_fearsome;
+const int BlockHashTest::index_of_space_in_eat_itself;
+const int BlockHashTest::index_of_i_in_itself;
+const int BlockHashTest::index_of_t_in_use_the;
+const int BlockHashTest::index_of_o_in_online;
+
+const char BlockHashTest::sample_text_without_spaces[] =
+    "The only thing we have to fear is fear itself";
+
+const char BlockHashTest::search_string_without_spaces[] =
+    "What we hear is fearsome";
+
+const char BlockHashTest::search_string_altered_without_spaces[] =
+    "Vhat ve hear is fearsomm";
+
+const char BlockHashTest::search_to_end_without_spaces[] =
+    "Pop will eat itself, eventually";
+
+const char BlockHashTest::search_to_beginning_without_spaces[] =
+    "Use The online dictionary";
+
+const char BlockHashTest::sample_text_many_matches_without_spaces[] =
+    "ababababcab";
+
+const char BlockHashTest::search_string_many_matches_without_spaces[] =
+    "ababc";
+
+const char* BlockHashTest::sample_text = NULL;
+const char* BlockHashTest::search_string = NULL;
+const char* BlockHashTest::search_string_altered = NULL;
+const char* BlockHashTest::search_to_end_string = NULL;
+const char* BlockHashTest::search_to_beginning_string = NULL;
+const char* BlockHashTest::sample_text_many_matches = NULL;
+const char* BlockHashTest::search_string_many_matches = NULL;
+
+const char* BlockHashTest::test_string_y = NULL;
+const char* BlockHashTest::test_string_e = NULL;
+const char* BlockHashTest::test_string_unaligned_e = NULL;
+const char* BlockHashTest::test_string_all_Qs = NULL;
+
+uint32_t BlockHashTest::hashed_y = 0;
+uint32_t BlockHashTest::hashed_e = 0;
+uint32_t BlockHashTest::hashed_f = 0;
+uint32_t BlockHashTest::hashed_unaligned_e = 0;
+uint32_t BlockHashTest::hashed_all_Qs = 0;
+
+// The two strings passed to BlockHash::MatchingBytesToLeft do have matching
+// characters -- in fact, they're the same string -- but since max_bytes is zero
+// or negative, BlockHash::MatchingBytesToLeft should not read from the strings
+// and should return 0.
+TEST_F(BlockHashTest, MaxBytesZeroDoesNothing) {
+  EXPECT_EQ(0, MatchingBytesToLeft(
+      &search_string[index_of_f_in_fearsome],
+      &search_string[index_of_f_in_fearsome],
+      0));
+  EXPECT_EQ(0, MatchingBytesToRight(
+      &search_string[index_of_f_in_fearsome],
+      &search_string[index_of_f_in_fearsome],
+      0));
+}
+
+TEST_F(BlockHashTest, MaxBytesNegativeDoesNothing) {
+  EXPECT_EQ(0, MatchingBytesToLeft(
+      &search_string[index_of_f_in_fearsome],
+      &search_string[index_of_f_in_fearsome],
+      -1));
+  EXPECT_EQ(0, MatchingBytesToLeft(
+      &search_string[index_of_f_in_fearsome],
+      &search_string[index_of_f_in_fearsome],
+      INT_MIN));
+  EXPECT_EQ(0, MatchingBytesToRight(
+      &search_string[index_of_f_in_fearsome],
+      &search_string[index_of_f_in_fearsome],
+      -1));
+  EXPECT_EQ(0, MatchingBytesToRight(
+      &search_string[index_of_f_in_fearsome],
+      &search_string[index_of_f_in_fearsome],
+      INT_MIN));
+}
+
+TEST_F(BlockHashTest, MaxBytesOneMatch) {
+  EXPECT_EQ(1, MatchingBytesToLeft(
+      &search_string[index_of_f_in_fearsome],
+      &search_string[index_of_f_in_fearsome],
+      1));
+  EXPECT_EQ(1, MatchingBytesToRight(
+      &search_string[index_of_f_in_fearsome],
+      &search_string[index_of_f_in_fearsome],
+      1));
+}
+
+TEST_F(BlockHashTest, MaxBytesOneNoMatch) {
+  EXPECT_EQ(0, MatchingBytesToLeft(
+      &search_string[index_of_f_in_fearsome],
+      &search_string[index_of_second_e_in_what_we_hear],
+      1));
+  EXPECT_EQ(0, MatchingBytesToRight(
+      &search_string[index_of_f_in_fearsome],
+      &search_string[index_of_second_e_in_what_we_hear - 1],
+      1));
+}
+
+TEST_F(BlockHashTest, LeftLimitedByMaxBytes) {
+  // The number of bytes that match between the original "we hear is fearsome"
+  // and the altered "ve hear is fearsome".
+  const int expected_length = kBlockSize * StringLengthAsInt("e hear is ");
+  const int max_bytes = expected_length - 1;
+  EXPECT_EQ(max_bytes, MatchingBytesToLeft(
+      &search_string[index_of_f_in_fearsome],
+      &search_string_altered[index_of_f_in_fearsome],
+      max_bytes));
+}
+
+TEST_F(BlockHashTest, LeftNotLimited) {
+  // The number of bytes that match between the original "we hear is fearsome"
+  // and the altered "ve hear is fearsome".
+  const int expected_length = kBlockSize * StringLengthAsInt("e hear is ");
+  const int max_bytes = expected_length + 1;
+  EXPECT_EQ(expected_length, MatchingBytesToLeft(
+      &search_string[index_of_f_in_fearsome],
+      &search_string_altered[index_of_f_in_fearsome],
+      max_bytes));
+  EXPECT_EQ(expected_length, MatchingBytesToLeft(
+      &search_string[index_of_f_in_fearsome],
+      &search_string_altered[index_of_f_in_fearsome],
+      INT_MAX));
+}
+
+TEST_F(BlockHashTest, RightLimitedByMaxBytes) {
+  // The number of bytes that match between the original "fearsome"
+  // and the altered "fearsomm".
+  const int expected_length = (kBlockSize * StringLengthAsInt("fearsom"))
+                              + (kBlockSize - 1);  // spacing between letters
+  const int max_bytes = expected_length - 1;
+  EXPECT_EQ(max_bytes, MatchingBytesToRight(
+      &search_string[index_of_f_in_fearsome],
+      &search_string_altered[index_of_f_in_fearsome],
+      max_bytes));
+}
+
+TEST_F(BlockHashTest, RightNotLimited) {
+  // The number of bytes that match between the original "we hear is fearsome"
+  // and the altered "ve hear is fearsome".
+  const int expected_length = (kBlockSize * StringLengthAsInt("fearsom"))
+                              + (kBlockSize - 1);  // spacing between letters
+  const int max_bytes = expected_length + 1;
+  EXPECT_EQ(expected_length, MatchingBytesToRight(
+      &search_string[index_of_f_in_fearsome],
+      &search_string_altered[index_of_f_in_fearsome],
+      max_bytes));
+  EXPECT_EQ(expected_length, MatchingBytesToRight(
+      &search_string[index_of_f_in_fearsome],
+      &search_string_altered[index_of_f_in_fearsome],
+      INT_MAX));
+}
+
+TEST_F(BlockHashTest, BlockContentsMatchIsFasterThanMemcmp) {
+  compare_buffer_1_ = new char[kTimingTestSize];
+  compare_buffer_2_ = new char[kTimingTestSize];
+
+  // The value 0xBE is arbitrarily chosen.  First test with identical contents
+  // in the buffers, so that the comparison functions cannot short-circuit
+  // and will return true.
+  memset(compare_buffer_1_, 0xBE, kTimingTestSize);
+  memset(compare_buffer_2_, 0xBE, kTimingTestSize);
+  LOG(INFO) << "Comparing " << kTimingTestSize << " identical values:"
+            << LOG_ENDL;
+  TestAndPrintTimesForCompareFunctions(true);
+
+  // Now change one value in the middle of one buffer, so that the contents
+  // are no longer the same.
+  compare_buffer_1_[kTimingTestSize / 2] = 0x00;
+  LOG(INFO) << "Comparing " << (kTimingTestSize - 1) << " identical values"
+            << " and one mismatch:" << LOG_ENDL;
+  TestAndPrintTimesForCompareFunctions(false);
+
+  // Set one of the bytes of each block to differ so that
+  // none of the compare operations will return true, and run timing tests.
+  // In practice, BlockHash::BlockContentsMatch will only be called
+  // for two blocks whose hash values match, and the two most important
+  // cases are: (1) the blocks are identical, or (2) none of their bytes match.
+  TimingTestForBlocksThatDifferAtByte(0);
+  TimingTestForBlocksThatDifferAtByte(1);
+  TimingTestForBlocksThatDifferAtByte(kBlockSize / 2);
+  TimingTestForBlocksThatDifferAtByte(kBlockSize - 1);
+
+  delete[] compare_buffer_1_;
+  delete[] compare_buffer_2_;
+}
+
+TEST_F(BlockHashTest, FindFailsBeforeHashing) {
+  EXPECT_EQ(-1, FirstMatchingBlock(*th_, hashed_y, test_string_y));
+}
+
+TEST_F(BlockHashTest, HashOneFindOne) {
+  for (int i = 0; i <= index_of_y_in_only; ++i) {
+    th_->AddOneIndexHash(i, RollingHash<kBlockSize>::Hash(&sample_text[i]));
+  }
+  EXPECT_EQ(block_of_y_in_only, FirstMatchingBlock(*th_, hashed_y,
+                                                   test_string_y));
+  EXPECT_EQ(-1, NextMatchingBlock(*th_, block_of_y_in_only, test_string_y));
+}
+
+TEST_F(BlockHashTest, HashAllFindOne) {
+  EXPECT_EQ(block_of_y_in_only, FirstMatchingBlock(*dh_, hashed_y,
+                                                   test_string_y));
+  EXPECT_EQ(-1, NextMatchingBlock(*dh_, block_of_y_in_only, test_string_y));
+}
+
+TEST_F(BlockHashTest, NonMatchingTextNotFound) {
+  EXPECT_EQ(-1, FirstMatchingBlock(*dh_, hashed_all_Qs, test_string_all_Qs));
+}
+
+// Search for unaligned text.  The test string is contained in the
+// sample text (unlike the non-matching string in NonMatchingTextNotFound,
+// above), but it is not aligned on a block boundary.  FindMatchingBlock
+// will only work if the test string is aligned on a block boundary.
+//
+//    "   T   h   e       o   n   l   y"
+//              ^^^^ Here is the test string
+//
+TEST_F(BlockHashTest, UnalignedTextNotFound) {
+  EXPECT_EQ(-1, FirstMatchingBlock(*dh_, hashed_unaligned_e,
+                                   test_string_unaligned_e));
+}
+
+TEST_F(BlockHashTest, FindSixMatches) {
+  EXPECT_EQ(block_of_first_e, FirstMatchingBlock(*dh_, hashed_e,
+                                                 test_string_e));
+  EXPECT_EQ(block_of_second_e, NextMatchingBlock(*dh_, block_of_first_e,
+                                                 test_string_e));
+  EXPECT_EQ(block_of_third_e, NextMatchingBlock(*dh_, block_of_second_e,
+                                                test_string_e));
+  EXPECT_EQ(block_of_fourth_e, NextMatchingBlock(*dh_, block_of_third_e,
+                                                 test_string_e));
+  EXPECT_EQ(block_of_fifth_e, NextMatchingBlock(*dh_, block_of_fourth_e,
+                                                test_string_e));
+  EXPECT_EQ(block_of_sixth_e, NextMatchingBlock(*dh_, block_of_fifth_e,
+                                                test_string_e));
+  EXPECT_EQ(-1, NextMatchingBlock(*dh_, block_of_sixth_e, test_string_e));
+
+  // Starting over gives same result
+  EXPECT_EQ(block_of_first_e, FirstMatchingBlock(*dh_, hashed_e,
+                                                 test_string_e));
+}
+
+TEST_F(BlockHashTest, AddRangeFindThreeMatches) {
+  // Add hash values only for those characters before the fourth instance
+  // of "e" in the sample text.  Tests that the ending index
+  // of AddAllBlocksThroughIndex() is not inclusive: only three matches
+  // for "e" should be found.
+  th_->AddAllBlocksThroughIndex(index_of_fourth_e);
+  EXPECT_EQ(block_of_first_e, FirstMatchingBlock(*th_, hashed_e,
+                                                 test_string_e));
+  EXPECT_EQ(block_of_second_e, NextMatchingBlock(*th_, block_of_first_e,
+                                                 test_string_e));
+  EXPECT_EQ(block_of_third_e, NextMatchingBlock(*th_, block_of_second_e,
+                                                test_string_e));
+  EXPECT_EQ(-1, NextMatchingBlock(*th_, block_of_third_e, test_string_e));
+
+  // Starting over gives same result
+  EXPECT_EQ(block_of_first_e, FirstMatchingBlock(*th_, hashed_e,
+                                                 test_string_e));
+}
+
+// Try indices that are not even multiples of the block size.
+// Add three ranges and verify the results after each
+// call to AddAllBlocksThroughIndex().
+TEST_F(BlockHashTest, AddRangeWithUnalignedIndices) {
+  th_->AddAllBlocksThroughIndex(index_of_first_e + 1);
+  EXPECT_EQ(block_of_first_e, FirstMatchingBlock(*th_, hashed_e,
+                                                 test_string_e));
+  EXPECT_EQ(-1, NextMatchingBlock(*th_, block_of_first_e, test_string_e));
+
+  // Starting over gives same result
+  EXPECT_EQ(block_of_first_e, FirstMatchingBlock(*th_, hashed_e,
+                                                 test_string_e));
+
+  // Add the second range to expand the result set
+  th_->AddAllBlocksThroughIndex(index_of_fourth_e - 3);
+  EXPECT_EQ(block_of_first_e, FirstMatchingBlock(*th_, hashed_e,
+                                                 test_string_e));
+  EXPECT_EQ(block_of_second_e, NextMatchingBlock(*th_, block_of_first_e,
+                                                 test_string_e));
+  EXPECT_EQ(block_of_third_e, NextMatchingBlock(*th_, block_of_second_e,
+                                                test_string_e));
+  EXPECT_EQ(-1, NextMatchingBlock(*th_, block_of_third_e, test_string_e));
+
+  // Starting over gives same result
+  EXPECT_EQ(block_of_first_e, FirstMatchingBlock(*th_, hashed_e,
+                                                 test_string_e));
+
+  // Add the third range to expand the result set
+  th_->AddAllBlocksThroughIndex(index_of_fourth_e + 1);
+
+  EXPECT_EQ(block_of_first_e, FirstMatchingBlock(*th_, hashed_e,
+                                                 test_string_e));
+  EXPECT_EQ(block_of_second_e, NextMatchingBlock(*th_, block_of_first_e,
+                                                 test_string_e));
+  EXPECT_EQ(block_of_third_e, NextMatchingBlock(*th_, block_of_second_e,
+                                                test_string_e));
+  EXPECT_EQ(block_of_fourth_e, NextMatchingBlock(*th_, block_of_third_e,
+                                                 test_string_e));
+  EXPECT_EQ(-1, NextMatchingBlock(*th_, block_of_fourth_e, test_string_e));
+
+  // Starting over gives same result
+  EXPECT_EQ(block_of_first_e, FirstMatchingBlock(*th_, hashed_e,
+                                                 test_string_e));
+}
+
+#ifdef GTEST_HAS_DEATH_TEST
+TEST_F(BlockHashDeathTest, AddingRangesInDescendingOrderNoEffect) {
+  th_->AddAllBlocksThroughIndex(index_of_fourth_e + 1);
+
+  EXPECT_EQ(block_of_first_e, FirstMatchingBlock(*th_, hashed_e,
+                                                 test_string_e));
+  EXPECT_EQ(block_of_second_e, NextMatchingBlock(*th_, block_of_first_e,
+                                                 test_string_e));
+  EXPECT_EQ(block_of_third_e, NextMatchingBlock(*th_, block_of_second_e,
+                                                test_string_e));
+  EXPECT_EQ(block_of_fourth_e, NextMatchingBlock(*th_, block_of_third_e,
+                                                 test_string_e));
+  EXPECT_EQ(-1, NextMatchingBlock(*th_, block_of_fourth_e, test_string_e));
+
+  // Starting over gives same result
+  EXPECT_EQ(block_of_first_e, FirstMatchingBlock(*th_, hashed_e,
+                                                 test_string_e));
+
+  // These calls will produce DFATAL error messages, and will do nothing,
+  // since the ranges have already been added.
+  EXPECT_DEBUG_DEATH(th_->AddAllBlocksThroughIndex(index_of_fourth_e - 3),
+                     "<");
+  EXPECT_DEBUG_DEATH(th_->AddAllBlocksThroughIndex(index_of_first_e + 1),
+                     "<");
+
+  EXPECT_EQ(block_of_first_e, FirstMatchingBlock(*th_, hashed_e,
+                                                 test_string_e));
+  EXPECT_EQ(block_of_second_e, NextMatchingBlock(*th_, block_of_first_e,
+                                                 test_string_e));
+  EXPECT_EQ(block_of_third_e, NextMatchingBlock(*th_, block_of_second_e,
+                                                test_string_e));
+  EXPECT_EQ(block_of_fourth_e, NextMatchingBlock(*th_, block_of_third_e,
+                                                 test_string_e));
+  EXPECT_EQ(-1, NextMatchingBlock(*th_, block_of_fourth_e, test_string_e));
+
+  // Starting over gives same result
+  EXPECT_EQ(block_of_first_e, FirstMatchingBlock(*th_, hashed_e,
+                                                 test_string_e));
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+TEST_F(BlockHashTest, AddEntireRangeFindSixMatches) {
+  th_->AddAllBlocksThroughIndex(StringLengthAsInt(sample_text));
+  EXPECT_EQ(block_of_first_e, FirstMatchingBlock(*th_, hashed_e,
+                                                 test_string_e));
+  EXPECT_EQ(block_of_second_e, NextMatchingBlock(*th_, block_of_first_e,
+                                                 test_string_e));
+  EXPECT_EQ(block_of_third_e, NextMatchingBlock(*th_, block_of_second_e,
+                                                test_string_e));
+  EXPECT_EQ(block_of_fourth_e, NextMatchingBlock(*th_, block_of_third_e,
+                                                 test_string_e));
+  EXPECT_EQ(block_of_fifth_e, NextMatchingBlock(*th_, block_of_fourth_e,
+                                                test_string_e));
+  EXPECT_EQ(block_of_sixth_e, NextMatchingBlock(*th_, block_of_fifth_e,
+                                                test_string_e));
+  EXPECT_EQ(-1, NextMatchingBlock(*th_, block_of_sixth_e, test_string_e));
+
+  // Starting over gives same result
+  EXPECT_EQ(block_of_first_e, FirstMatchingBlock(*th_, hashed_e,
+                                                 test_string_e));
+}
+
+TEST_F(BlockHashTest, ZeroSizeSourceAccepted) {
+  BlockHash zero_sized_hash(sample_text, 0, 0);
+  EXPECT_EQ(true, zero_sized_hash.Init(true));
+  EXPECT_EQ(-1, FirstMatchingBlock(*th_, hashed_y, test_string_y));
+}
+
+#ifdef GTEST_HAS_DEATH_TEST
+TEST_F(BlockHashDeathTest, BadNextMatchingBlockReturnsNoMatch) {
+  EXPECT_DEBUG_DEATH(EXPECT_EQ(-1, NextMatchingBlock(*dh_, 0xFFFFFFFE, "    ")),
+                     "invalid");
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+TEST_F(BlockHashTest, UnknownFingerprintReturnsNoMatch) {
+  EXPECT_EQ(-1, FirstMatchingBlock(*dh_, 0xFAFAFAFA, "FAFA"));
+}
+
+TEST_F(BlockHashTest, FindBestMatch) {
+  dh_->FindBestMatch(hashed_f,
+                     &search_string[index_of_f_in_fearsome],
+                     search_string,
+                     strlen(search_string),
+                     &best_match_);
+  EXPECT_EQ(index_of_longest_match_ear_is_fear, best_match_.source_offset());
+  EXPECT_EQ(index_of_second_e_in_what_we_hear, best_match_.target_offset());
+  // The match includes the spaces after the final character,
+  // which is why (kBlockSize - 1) is added to the expected best size.
+  EXPECT_EQ((strlen("ear is fear") * kBlockSize) + (kBlockSize - 1),
+            best_match_.size());
+}
+
+TEST_F(BlockHashTest, FindBestMatchWithStartingOffset) {
+  BlockHash th2(sample_text, strlen(sample_text), 0x10000);
+  th2.Init(true);  // hash all blocks
+  th2.FindBestMatch(hashed_f,
+                    &search_string[index_of_f_in_fearsome],
+                    search_string,
+                    strlen(search_string),
+                    &best_match_);
+  // Offset should begin with dictionary_size
+  EXPECT_EQ(0x10000 + (index_of_longest_match_ear_is_fear),
+            best_match_.source_offset());
+  EXPECT_EQ(index_of_second_e_in_what_we_hear, best_match_.target_offset());
+  // The match includes the spaces after the final character,
+  // which is why (kBlockSize - 1) is added to the expected best size.
+  EXPECT_EQ((strlen("ear is fear") * kBlockSize) + (kBlockSize - 1),
+            best_match_.size());
+}
+
+TEST_F(BlockHashTest, BestMatchReachesEndOfDictionary) {
+  // Hash the "i" in "fear itself"
+  uint32_t hash_value = RollingHash<kBlockSize>::Hash(
+      &search_to_end_string[index_of_i_in_itself]);
+  dh_->FindBestMatch(hash_value,
+                     &search_to_end_string[index_of_i_in_itself],
+                     search_to_end_string,
+                     strlen(search_to_end_string),
+                     &best_match_);
+  EXPECT_EQ(index_of_space_before_itself, best_match_.source_offset());
+  EXPECT_EQ(index_of_space_in_eat_itself, best_match_.target_offset());
+  EXPECT_EQ(strlen(" itself") * kBlockSize, best_match_.size());
+}
+
+TEST_F(BlockHashTest, BestMatchReachesStartOfDictionary) {
+  // Hash the "i" in "fear itself"
+  uint32_t hash_value = RollingHash<kBlockSize>::Hash(
+      &search_to_beginning_string[index_of_o_in_online]);
+  dh_->FindBestMatch(hash_value,
+                     &search_to_beginning_string[index_of_o_in_online],
+                     search_to_beginning_string,
+                     strlen(search_to_beginning_string),
+                     &best_match_);
+  EXPECT_EQ(0, best_match_.source_offset());  // beginning of dictionary
+  EXPECT_EQ(index_of_t_in_use_the, best_match_.target_offset());
+  // The match includes the spaces after the final character,
+  // which is why (kBlockSize - 1) is added to the expected best size.
+  EXPECT_EQ((strlen("The onl") * kBlockSize) + (kBlockSize - 1),
+            best_match_.size());
+}
+
+TEST_F(BlockHashTest, BestMatchWithManyMatches) {
+  BlockHash many_matches_hash(sample_text_many_matches,
+                              strlen(sample_text_many_matches),
+                              0);
+  EXPECT_TRUE(many_matches_hash.Init(true));
+  // Hash the "   a" at the beginning of the search string "ababc"
+  uint32_t hash_value =
+      RollingHash<kBlockSize>::Hash(search_string_many_matches);
+  many_matches_hash.FindBestMatch(hash_value,
+                                  search_string_many_matches,
+                                  search_string_many_matches,
+                                  strlen(search_string_many_matches),
+                                  &best_match_);
+  EXPECT_EQ(index_of_ababc, best_match_.source_offset());
+  EXPECT_EQ(0, best_match_.target_offset());
+  EXPECT_EQ(strlen(search_string_many_matches), best_match_.size());
+}
+
+TEST_F(BlockHashTest, HashCollisionFindsNoMatch) {
+  char* collision_search_string = new char[strlen(search_string) + 1];
+  memcpy(collision_search_string, search_string, strlen(search_string) + 1);
+  char* fearsome_location = &collision_search_string[index_of_f_in_fearsome];
+
+  // Tweak the collision string so that it has the same hash value
+  // but different text.  The last four characters of the search string
+  // should be "   f", and the bytes given below have the same hash value
+  // as those characters.
+  CHECK_GE(kBlockSize, 4);
+  fearsome_location[kBlockSize - 4] = 0x84;
+  fearsome_location[kBlockSize - 3] = 0xF1;
+  fearsome_location[kBlockSize - 2] = 0x51;
+  fearsome_location[kBlockSize - 1] = 0x00;
+  EXPECT_EQ(hashed_f, RollingHash<kBlockSize>::Hash(fearsome_location));
+  EXPECT_NE(0, memcmp(&search_string[index_of_f_in_fearsome],
+                      fearsome_location,
+                      kBlockSize));
+  // No match should be found this time.
+  dh_->FindBestMatch(hashed_f,
+      fearsome_location,
+      collision_search_string,
+      strlen(search_string),  // since collision_search_string has embedded \0
+      &best_match_);
+  EXPECT_EQ(-1, best_match_.source_offset());
+  EXPECT_EQ(-1, best_match_.target_offset());
+  EXPECT_EQ(0U, best_match_.size());
+  delete[] collision_search_string;
+}
+
+// If the footprint passed to FindBestMatch does not actually match
+// the search string, it should not find any matches.
+TEST_F(BlockHashTest, WrongFootprintFindsNoMatch) {
+  dh_->FindBestMatch(hashed_e,  // Using hashed value of "e" instead of "f"!
+                     &search_string[index_of_f_in_fearsome],
+                     search_string,
+                     strlen(search_string),
+                     &best_match_);
+  EXPECT_EQ(-1, best_match_.source_offset());
+  EXPECT_EQ(-1, best_match_.target_offset());
+  EXPECT_EQ(0U, best_match_.size());
+}
+
+// Use a dictionary containing 1M copies of the letter 'Q',
+// and target data that also contains 1M Qs.  If FindBestMatch
+// is not throttled to find a maximum number of matches, this
+// will take a very long time -- several seconds at least.
+// If this test appears to hang, it is because the throttling code
+// (see BlockHash::kMaxMatchesToCheck for details) is not working.
+TEST_F(BlockHashTest, SearchStringFindsTooManyMatches) {
+  const int kTestSize = 1 << 20;  // 1M
+  char* huge_dictionary = new char[kTestSize];
+  memset(huge_dictionary, 'Q', kTestSize);
+  BlockHash huge_bh(huge_dictionary, kTestSize, 0);
+  EXPECT_TRUE(huge_bh.Init(/* populate_hash_table = */ true));
+  char* huge_target = new char[kTestSize];
+  memset(huge_target, 'Q', kTestSize);
+  CycleTimer timer;
+  timer.Start();
+  huge_bh.FindBestMatch(hashed_all_Qs,
+                        huge_target + (kTestSize / 2),  // middle of target
+                        huge_target,
+                        kTestSize,
+                        &best_match_);
+  timer.Stop();
+  double elapsed_time_in_us = static_cast<double>(timer.GetInUsec());
+  LOG(INFO) << "Time to search for best match with 1M matches: "
+            << elapsed_time_in_us << " us" << LOG_ENDL;
+  // All blocks match the candidate block.  FindBestMatch should have checked
+  // a certain number of matches before giving up.  The best match
+  // should include at least half the source and target, since the candidate
+  // block was in the middle of the target data.
+  EXPECT_GT((kTestSize / 2), best_match_.source_offset());
+  EXPECT_GT((kTestSize / 2), best_match_.target_offset());
+  EXPECT_LT(static_cast<size_t>(kTestSize / 2), best_match_.size());
+  EXPECT_GT(1000000, elapsed_time_in_us);  // < 1 second
+  delete[] huge_target;
+  delete[] huge_dictionary;
+}
+
+#ifdef GTEST_HAS_DEATH_TEST
+TEST_F(BlockHashDeathTest, AddTooManyBlocks) {
+  for (int i = 0; i < StringLengthAsInt(sample_text_without_spaces); ++i) {
+    th_->AddOneIndexHash(i * kBlockSize, hashed_e);
+  }
+  // Didn't expect another block to be added
+  EXPECT_DEBUG_DEATH(th_->AddOneIndexHash(StringLengthAsInt(sample_text),
+                                          hashed_e),
+                     "AddBlock");
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+}  //  namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/checksum.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/checksum.h
new file mode 100644
index 0000000..0d315a1
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/checksum.h
@@ -0,0 +1,48 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// A wrapper for the adler32() function from zlib.  This can be replaced
+// with another checksum implementation if desired.
+
+#ifndef OPEN_VCDIFF_CHECKSUM_H_
+#define OPEN_VCDIFF_CHECKSUM_H_
+
+#include <config.h>
+#include "zlib.h"
+
+namespace open_vcdiff {
+
+typedef uLong VCDChecksum;
+
+const VCDChecksum kNoPartialChecksum = 0;
+
+inline VCDChecksum ComputeAdler32(const char* buffer,
+                                  size_t size) {
+  return adler32(kNoPartialChecksum,
+                 reinterpret_cast<const Bytef*>(buffer),
+                 static_cast<uInt>(size));
+}
+
+inline VCDChecksum UpdateAdler32(VCDChecksum partial_checksum,
+                                 const char* buffer,
+                                 size_t size) {
+  return adler32(partial_checksum,
+                 reinterpret_cast<const Bytef*>(buffer),
+                 static_cast<uInt>(size));
+}
+
+}  // namespace open_vcdiff
+
+#endif  // OPEN_VCDIFF_CHECKSUM_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/codetable.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/codetable.cc
new file mode 100644
index 0000000..117ed7e
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/codetable.cc
@@ -0,0 +1,279 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// codetable.cc:
+//     Classes to implement the Code Table
+//     described in sections 5.5, 5.6 and 7 of
+//     RFC 3284 - The VCDIFF Generic Differencing and Compression Data Format.
+//     The RFC text can be found at http://www.faqs.org/rfcs/rfc3284.html
+
+#include <config.h>
+#include "addrcache.h"
+#include "codetable.h"
+#include "logging.h"
+#include "vcdiff_defs.h"  // VCD_MAX_MODES
+
+namespace open_vcdiff {
+
+const char* VCDiffInstructionName(VCDiffInstructionType inst) {
+  switch (inst) {
+    case VCD_NOOP:
+      return "NOOP";
+    case VCD_ADD:
+      return "ADD";
+    case VCD_RUN:
+      return "RUN";
+    case VCD_COPY:
+      return "COPY";
+    default:
+      LOG(ERROR) << "Unexpected instruction type " << inst << LOG_ENDL;
+      return "";
+  }
+}
+
+// This is the default code table defined in the RFC, section 5.6.
+// Using a static struct means that the compiler will do the work of
+// laying out the values in memory rather than having to use loops to do so
+// at runtime.  The letters "N", "A", "R", and "C" are defined as VCD_NOOP,
+// VCD_ADD, VCD_RUN, and VCD_COPY respectively (see the definition of
+// struct VCDiffCodeTableData), which allows for a compact
+// representation of the code table data.
+//
+const VCDiffCodeTableData VCDiffCodeTableData::kDefaultCodeTableData =
+    // inst1
+    { { R,  // opcode 0
+        A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A,  // opcodes 1-18
+        C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,  // opcodes 19-34
+        C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,  // opcodes 35-50
+        C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,  // opcodes 51-66
+        C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,  // opcodes 67-82
+        C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,  // opcodes 83-98
+        C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,  // opcodes 99-114
+        C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,  // opcodes 115-130
+        C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,  // opcodes 131-146
+        C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,  // opcodes 147-162
+        A, A, A, A, A, A, A, A, A, A, A, A,  // opcodes 163-174
+        A, A, A, A, A, A, A, A, A, A, A, A,  // opcodes 175-186
+        A, A, A, A, A, A, A, A, A, A, A, A,  // opcodes 187-198
+        A, A, A, A, A, A, A, A, A, A, A, A,  // opcodes 199-210
+        A, A, A, A, A, A, A, A, A, A, A, A,  // opcodes 211-222
+        A, A, A, A, A, A, A, A, A, A, A, A,  // opcodes 223-234
+        A, A, A, A,  // opcodes 235-238
+        A, A, A, A,  // opcodes 239-242
+        A, A, A, A,  // opcodes 243-246
+        C, C, C, C, C, C, C, C, C },  // opcodes 247-255
+    // inst2
+      { N,  // opcode 0
+        N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N,  // opcodes 1-18
+        N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N,  // opcodes 19-34
+        N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N,  // opcodes 35-50
+        N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N,  // opcodes 51-66
+        N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N,  // opcodes 67-82
+        N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N,  // opcodes 83-98
+        N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N,  // opcodes 99-114
+        N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N,  // opcodes 115-130
+        N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N,  // opcodes 131-146
+        N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N,  // opcodes 147-162
+        C, C, C, C, C, C, C, C, C, C, C, C,  // opcodes 163-174
+        C, C, C, C, C, C, C, C, C, C, C, C,  // opcodes 175-186
+        C, C, C, C, C, C, C, C, C, C, C, C,  // opcodes 187-198
+        C, C, C, C, C, C, C, C, C, C, C, C,  // opcodes 199-210
+        C, C, C, C, C, C, C, C, C, C, C, C,  // opcodes 211-222
+        C, C, C, C, C, C, C, C, C, C, C, C,  // opcodes 223-234
+        C, C, C, C,  // opcodes 235-238
+        C, C, C, C,  // opcodes 239-242
+        C, C, C, C,  // opcodes 243-246
+        A, A, A, A, A, A, A, A, A },  // opcodes 247-255
+    // size1
+      { 0,  // opcode 0
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,  // 1-18
+        0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,  // 19-34
+        0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,  // 35-50
+        0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,  // 51-66
+        0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,  // 67-82
+        0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,  // 83-98
+        0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,  // 99-114
+        0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,  // 115-130
+        0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,  // 131-146
+        0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,  // 147-162
+        1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4,  // opcodes 163-174
+        1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4,  // opcodes 175-186
+        1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4,  // opcodes 187-198
+        1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4,  // opcodes 199-210
+        1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4,  // opcodes 211-222
+        1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4,  // opcodes 223-234
+        1, 2, 3, 4,  // opcodes 235-238
+        1, 2, 3, 4,  // opcodes 239-242
+        1, 2, 3, 4,  // opcodes 243-246
+        4, 4, 4, 4, 4, 4, 4, 4, 4 },  // opcodes 247-255
+    // size2
+      { 0,  // opcode 0
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 1-18
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 19-34
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 35-50
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 51-66
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 67-82
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 83-98
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 99-114
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 115-130
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 131-146
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 147-162
+        4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6,  // opcodes 163-174
+        4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6,  // opcodes 175-186
+        4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6,  // opcodes 187-198
+        4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6,  // opcodes 199-210
+        4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6,  // opcodes 211-222
+        4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6,  // opcodes 223-234
+        4, 4, 4, 4,  // opcodes 235-238
+        4, 4, 4, 4,  // opcodes 239-242
+        4, 4, 4, 4,  // opcodes 243-246
+        1, 1, 1, 1, 1, 1, 1, 1, 1 },  // opcodes 247-255
+    // mode1
+      { 0,  // opcode 0
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 1-18
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 19-34
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // opcodes 35-50
+        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,  // opcodes 51-66
+        3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,  // opcodes 67-82
+        4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,  // opcodes 83-98
+        5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,  // opcodes 99-114
+        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,  // opcodes 115-130
+        7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,  // opcodes 131-146
+        8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,  // opcodes 147-162
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 163-174
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 175-186
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 187-198
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 199-210
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 211-222
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 223-234
+        0, 0, 0, 0,  // opcodes 235-238
+        0, 0, 0, 0,  // opcodes 239-242
+        0, 0, 0, 0,  // opcodes 243-246
+        0, 1, 2, 3, 4, 5, 6, 7, 8 },  // opcodes 247-255
+    // mode2
+      { 0,  // opcode 0
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 1-18
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 19-34
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 35-50
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 51-66
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 67-82
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 83-98
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 99-114
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 115-130
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 131-146
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 147-162
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // opcodes 163-174
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // opcodes 175-186
+        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,  // opcodes 187-198
+        3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,  // opcodes 199-210
+        4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,  // opcodes 211-222
+        5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,  // opcodes 223-234
+        6, 6, 6, 6,  // opcodes 235-238
+        7, 7, 7, 7,  // opcodes 239-242
+        8, 8, 8, 8,  // opcodes 243-246
+        0, 0, 0, 0, 0, 0, 0, 0, 0 } };  // opcodes 247-255
+
+bool VCDiffCodeTableData::ValidateOpcode(int opcode,
+                                         unsigned char inst,
+                                         unsigned char size,
+                                         unsigned char mode,
+                                         unsigned char max_mode,
+                                         const char* first_or_second) {
+  bool no_errors_found = true;
+  // Check upper limits of inst and mode.  inst, size, and mode are
+  // unsigned, so there is no lower limit on them.
+  if (inst > VCD_LAST_INSTRUCTION_TYPE) {
+    LOG(ERROR) << "VCDiff: Bad code table; opcode " << opcode << " has invalid "
+               << first_or_second << " instruction type "
+               << static_cast<int>(inst) << LOG_ENDL;
+    no_errors_found = false;
+  }
+  if (mode > max_mode) {
+    LOG(ERROR) << "VCDiff: Bad code table; opcode " << opcode << " has invalid "
+               << first_or_second << " mode "
+               << static_cast<int>(mode) << LOG_ENDL;
+    no_errors_found = false;
+  }
+  // A NOOP instruction must have size 0
+  // (and mode 0, which is included in the next rule)
+  if ((inst == VCD_NOOP) && (size != 0)) {
+    LOG(ERROR) << "VCDiff: Bad code table; opcode " << opcode << " has "
+               << first_or_second << " instruction NOOP with nonzero size "
+               << static_cast<int>(size) << LOG_ENDL;
+    no_errors_found = false;
+  }
+  // A nonzero mode can only be used with a COPY instruction
+  if ((inst != VCD_COPY) && (mode != 0)) {
+    LOG(ERROR) << "VCDiff: Bad code table; opcode " << opcode
+               << " has non-COPY "
+               << first_or_second << " instruction with nonzero mode "
+               << static_cast<int>(mode) << LOG_ENDL;
+    no_errors_found = false;
+  }
+  return no_errors_found;
+}
+
+// If an error is found while validating, continue to validate the rest
+// of the code table so that all validation errors will appear in
+// the error log.  Otherwise the user would have to fix a single error
+// and then rerun validation to find the next error.
+//
+bool VCDiffCodeTableData::Validate(unsigned char max_mode) const {
+  const int kNumberOfTypesAndModes = VCD_LAST_INSTRUCTION_TYPE + max_mode + 1;
+  bool hasOpcodeForTypeAndMode[VCD_LAST_INSTRUCTION_TYPE + VCD_MAX_MODES];
+  bool no_errors_found = true;
+  for (int i = 0; i < kNumberOfTypesAndModes; ++i) {
+    hasOpcodeForTypeAndMode[i] = false;
+  }
+  for (int i = 0; i < kCodeTableSize; ++i) {
+    no_errors_found =
+        ValidateOpcode(i, inst1[i], size1[i], mode1[i], max_mode, "first")
+        && no_errors_found;  // use as 2nd operand to avoid short-circuit
+    no_errors_found =
+        ValidateOpcode(i, inst2[i], size2[i], mode2[i], max_mode, "second")
+        && no_errors_found;
+    // A valid code table must have an opcode to encode every possible
+    // combination of inst and mode with size=0 as its first instruction,
+    // and NOOP as its second instruction.  If this condition fails,
+    // then there exists a set of input instructions that cannot be encoded.
+    if ((size1[i] == 0) &&
+        (inst2[i] == VCD_NOOP) &&
+        ((static_cast<int>(inst1[i]) + static_cast<int>(mode1[i]))
+            < kNumberOfTypesAndModes)) {
+      hasOpcodeForTypeAndMode[inst1[i] + mode1[i]] = true;
+    }
+  }
+  for (int i = 0; i < kNumberOfTypesAndModes; ++i) {
+    if (i == VCD_NOOP) continue;
+    if (!hasOpcodeForTypeAndMode[i])  {
+      if (i >= VCD_COPY) {
+        LOG(ERROR) << "VCDiff: Bad code table; there is no opcode for inst "
+                      "COPY, size 0, mode " << (i - VCD_COPY) << LOG_ENDL;
+      } else {
+        LOG(ERROR) << "VCDiff: Bad code table; there is no opcode for inst "
+            << VCDiffInstructionName(static_cast<VCDiffInstructionType>(i))
+            << ", size 0,  mode 0" << LOG_ENDL;
+      }
+      no_errors_found = false;
+    }
+  }
+  return no_errors_found;
+}
+
+bool VCDiffCodeTableData::Validate() const {
+  return Validate(VCDiffAddressCache::DefaultLastMode());
+}
+
+}  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/codetable.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/codetable.h
new file mode 100644
index 0000000..5beaa52
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/codetable.h
@@ -0,0 +1,127 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Classes to implement the Code Table
+// described in sections 5.5, 5.6 and 7 of
+// RFC 3284 - The VCDIFF Generic Differencing and Compression Data Format.
+// The RFC text can be found at http://www.faqs.org/rfcs/rfc3284.html
+
+#ifndef OPEN_VCDIFF_CODETABLE_H_
+#define OPEN_VCDIFF_CODETABLE_H_
+
+#include <config.h>
+#include <stdint.h>             // uint16_t
+
+namespace open_vcdiff {
+
+// The instruction types from section 5.5 (mistakenly labeled 5.4) of the RFC.
+//
+enum VCDiffInstructionType {
+  VCD_NOOP = 0,
+  VCD_ADD  = 1,
+  VCD_RUN  = 2,
+  VCD_COPY = 3,
+  VCD_LAST_INSTRUCTION_TYPE = VCD_COPY,
+  // The following values are not true instruction types, but rather
+  // special condition values for functions that return VCDiffInstructionType.
+  VCD_INSTRUCTION_ERROR = 4,
+  VCD_INSTRUCTION_END_OF_DATA = 5
+};
+
+const char* VCDiffInstructionName(VCDiffInstructionType inst);
+
+// OpcodeOrNone: An opcode is a value between 0-255.  There is not room
+// in a single byte to express all these values plus a "no opcode found"
+// value.  So use a 16-bit integer to hold either an opcode or kNoOpcode.
+//
+typedef uint16_t OpcodeOrNone;
+const OpcodeOrNone kNoOpcode = 0x100;  // outside the opcode range 0x00 - 0xFF
+
+// struct VCDiffCodeTableData:
+//
+// A representation of the VCDiff code table as six 256-byte arrays
+// as described in Section 7 of RFC 3284.  Each instruction code
+// can represent up to two delta instructions, which is why inst,
+// size, and mode each appear twice.  Each of the two delta instructions
+// has the following three attributes:
+// * inst (NOOP, ADD, RUN, or COPY)
+// * size (0-255 bytes) of the data to be copied; if this value is zero, then
+//   the size will be encoded separately from the instruction code, as a Varint
+// * mode (SELF, HERE, NEAR(n), or SAME(n)), only used for COPY instructions
+//
+// Every valid code table should contain AT LEAST the following instructions:
+//     inst1=ADD  size1=0 mode1=X inst2=NOOP size2=X mode2=X
+//     inst1=RUN  size1=0 mode1=X inst2=NOOP size2=X mode2=X
+//     inst1=COPY size1=0 mode1=N inst2=NOOP size2=X mode2=X (for all N)
+// ... where X represents a "don't care" value which will not be read,
+// and N stands for every possible COPY mode between 0 and
+// ([same cache size] + [here cache size]) inclusive.
+// Without these instructions, it will be impossible to guarantee that
+// all ADD, RUN, and COPY encoding requests can be fulfilled.
+//
+struct VCDiffCodeTableData {
+  static const int kCodeTableSize = 256;
+
+  static const VCDiffCodeTableData kDefaultCodeTableData;
+
+  // Validates that the data contained in the VCDiffCodeTableData structure
+  // does not violate certain assumptions.  Returns true if none of these
+  // assumptions are violated, or false if an unexpected value is found.
+  // This function should be called on any non-default code table that is
+  // received as part of an encoded transmission.
+  // max_mode is the maximum value for the mode of a COPY instruction;
+  // this is equal to same_cache_size + near_cache_size + 1.
+  //
+  bool Validate(unsigned char max_mode) const;
+
+  // This version of Validate() assumes that the default address cache sizes
+  // are being used, and calculates max_mode based on that assumption.
+  bool Validate() const;
+
+  // The names of these elements are taken from RFC 3284 section 5.4
+  // (Instruction Codes), which contains the following specification:
+  //
+  // Each instruction code entry contains six fields, each of which is a single
+  // byte with an unsigned value:
+  // +-----------------------------------------------+
+  // | inst1 | size1 | mode1 | inst2 | size2 | mode2 |
+  // +-----------------------------------------------+
+  //
+  unsigned char inst1[kCodeTableSize];  // from enum VCDiffInstructionType
+  unsigned char inst2[kCodeTableSize];  // from enum VCDiffInstructionType
+  unsigned char size1[kCodeTableSize];
+  unsigned char size2[kCodeTableSize];
+  unsigned char mode1[kCodeTableSize];  // from enum VCDiffModes
+  unsigned char mode2[kCodeTableSize];  // from enum VCDiffModes
+
+ private:
+  // Single-letter abbreviations that make it easier to read
+  // the default code table data.
+  static const VCDiffInstructionType N = VCD_NOOP;
+  static const VCDiffInstructionType A = VCD_ADD;
+  static const VCDiffInstructionType R = VCD_RUN;
+  static const VCDiffInstructionType C = VCD_COPY;
+
+  static bool ValidateOpcode(int opcode,
+                             unsigned char inst,
+                             unsigned char size,
+                             unsigned char mode,
+                             unsigned char max_mode,
+                             const char* first_or_second);
+};
+
+}  // namespace open_vcdiff
+
+#endif  // OPEN_VCDIFF_CODETABLE_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/codetable_test.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/codetable_test.cc
new file mode 100644
index 0000000..8e716fb
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/codetable_test.cc
@@ -0,0 +1,254 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Unit tests for struct VCDiffCodeTableData, found in codetable.h.
+
+#include <config.h>
+#include "codetable.h"
+#include "addrcache.h"
+#include "testing.h"
+
+namespace open_vcdiff {
+namespace {
+
+class CodeTableTest : public testing::Test {
+ protected:
+  CodeTableTest()
+  : code_table_data_(VCDiffCodeTableData::kDefaultCodeTableData) { }
+
+  virtual ~CodeTableTest() { }
+
+  virtual void SetUp() {
+    // Default code table must pass
+    EXPECT_TRUE(ValidateCodeTable());
+  }
+
+  static void AddExerciseOpcode(unsigned char inst1,
+                                unsigned char mode1,
+                                unsigned char size1,
+                                unsigned char inst2,
+                                unsigned char mode2,
+                                unsigned char size2,
+                                int opcode) {
+    g_exercise_code_table_->inst1[opcode] = inst1;
+    g_exercise_code_table_->mode1[opcode] = mode1;
+    g_exercise_code_table_->size1[opcode] = (inst1 == VCD_NOOP) ? 0 : size1;
+    g_exercise_code_table_->inst2[opcode] = inst2;
+    g_exercise_code_table_->mode2[opcode] = mode2;
+    g_exercise_code_table_->size2[opcode] = (inst2 == VCD_NOOP) ? 0 : size2;
+  }
+
+  static void SetUpTestCase() {
+    g_exercise_code_table_ = new VCDiffCodeTableData;
+    int opcode = 0;
+    for (unsigned char inst_mode1 = 0;
+         inst_mode1 <= VCD_LAST_INSTRUCTION_TYPE + kLastExerciseMode;
+         ++inst_mode1) {
+      unsigned char inst1 = inst_mode1;
+      unsigned char mode1 = 0;
+      if (inst_mode1 > VCD_COPY) {
+        inst1 = VCD_COPY;
+        mode1 = inst_mode1 - VCD_COPY;
+      }
+      for (unsigned char inst_mode2 = 0;
+           inst_mode2 <= VCD_LAST_INSTRUCTION_TYPE + kLastExerciseMode;
+           ++inst_mode2) {
+        unsigned char inst2 = inst_mode2;
+        unsigned char mode2 = 0;
+        if (inst_mode2 > VCD_COPY) {
+          inst2 = VCD_COPY;
+          mode2 = inst_mode2 - VCD_COPY;
+        }
+        AddExerciseOpcode(inst1, mode1, 0, inst2, mode2, 0, opcode++);
+        AddExerciseOpcode(inst1, mode1, 0, inst2, mode2, 255, opcode++);
+        AddExerciseOpcode(inst1, mode1, 255, inst2, mode2, 0, opcode++);
+        AddExerciseOpcode(inst1, mode1, 255, inst2, mode2, 255, opcode++);
+      }
+    }
+    // This is a CHECK rather than an EXPECT because it validates only
+    // the logic of the test, not of the code being tested.
+    CHECK_EQ(VCDiffCodeTableData::kCodeTableSize, opcode);
+
+    EXPECT_TRUE(VCDiffCodeTableData::kDefaultCodeTableData.Validate());
+    EXPECT_TRUE(g_exercise_code_table_->Validate(kLastExerciseMode));
+  }
+
+  static void TearDownTestCase() {
+    delete g_exercise_code_table_;
+  }
+
+  void VerifyInstruction(unsigned char opcode,
+                         unsigned char inst,
+                         unsigned char size,
+                         unsigned char mode) {
+    EXPECT_EQ(inst, code_table_data_.inst1[opcode]);
+    EXPECT_EQ(size, code_table_data_.size1[opcode]);
+    EXPECT_EQ(mode, code_table_data_.mode1[opcode]);
+    EXPECT_EQ(VCD_NOOP, code_table_data_.inst2[opcode]);
+    EXPECT_EQ(0, code_table_data_.size2[opcode]);
+    EXPECT_EQ(0, code_table_data_.mode2[opcode]);
+  }
+
+  bool ValidateCodeTable() {
+    return code_table_data_.Validate();
+  }
+
+  // This value is designed so that the total number of inst values and modes
+  // will equal 8 (VCD_NOOP, VCD_ADD, VCD_RUN, VCD_COPY modes 0 - 4).
+  // Eight combinations of inst and mode, times two possible size values,
+  // squared (because there are two instructions per opcode), makes
+  // exactly 256 possible instruction combinations, which fits kCodeTableSize
+  // (the number of opcodes in the table.)
+  static const int kLastExerciseMode = 4;
+
+  // A code table that exercises as many combinations as possible:
+  // 2 instructions, each is a NOOP, ADD, RUN, or one of 5 copy modes
+  // (== 8 total combinations of inst and mode), and each has
+  // size == 0 or 255 (2 possibilities.)
+  static VCDiffCodeTableData* g_exercise_code_table_;
+
+  // The code table used by the current test.
+  VCDiffCodeTableData code_table_data_;
+};
+
+VCDiffCodeTableData* CodeTableTest::g_exercise_code_table_ = NULL;
+
+// These tests make sure that ValidateCodeTable() catches particular
+// error conditions in a custom code table.
+
+// All possible combinations of inst and mode should have an opcode with size 0.
+TEST_F(CodeTableTest, MissingCopyMode) {
+  VerifyInstruction(/* opcode */ 131, VCD_COPY, /* size */ 0, /* mode */ 7);
+  code_table_data_.size1[131] = 0xFF;
+  // Now there is no opcode expressing COPY with mode 7 and size 0.
+  EXPECT_FALSE(ValidateCodeTable());
+}
+
+TEST_F(CodeTableTest, MissingAdd) {
+  VerifyInstruction(/* opcode */ 1, VCD_ADD, /* size */ 0, /* mode */ 0);
+  code_table_data_.size1[1] = 0xFF;  // Add size 0 => size 255
+  // Now there is no opcode expressing ADD with size 0.
+  EXPECT_FALSE(ValidateCodeTable());
+}
+
+TEST_F(CodeTableTest, MissingRun) {
+  VerifyInstruction(/* opcode */ 0, VCD_RUN, /* size */ 0, /* mode */ 0);
+  code_table_data_.size1[0] = 0xFF;  // Run size 0 => size 255
+  // Now there is no opcode expressing RUN with size 0.
+  EXPECT_FALSE(ValidateCodeTable());
+}
+
+TEST_F(CodeTableTest, BadOpcode) {
+  VerifyInstruction(/* opcode */ 0, VCD_RUN, /* size */ 0, /* mode */ 0);
+  code_table_data_.inst1[0] = VCD_LAST_INSTRUCTION_TYPE + 1;
+  EXPECT_FALSE(ValidateCodeTable());
+  code_table_data_.inst1[0] = 0xFF;
+  EXPECT_FALSE(ValidateCodeTable());
+}
+
+TEST_F(CodeTableTest, BadMode) {
+  VerifyInstruction(/* opcode */ 131, VCD_COPY, /* size */ 0, /* mode */ 7);
+  code_table_data_.mode1[131] = VCDiffAddressCache::DefaultLastMode() + 1;
+  EXPECT_FALSE(ValidateCodeTable());
+  code_table_data_.mode1[131] = 0xFF;
+  EXPECT_FALSE(ValidateCodeTable());
+}
+
+TEST_F(CodeTableTest, AddWithNonzeroMode) {
+  VerifyInstruction(/* opcode */ 1, VCD_ADD, /* size */ 0, /* mode */ 0);
+  code_table_data_.mode1[1] = 1;
+  EXPECT_FALSE(ValidateCodeTable());
+}
+
+TEST_F(CodeTableTest, RunWithNonzeroMode) {
+  VerifyInstruction(/* opcode */ 0, VCD_RUN, /* size */ 0, /* mode */ 0);
+  code_table_data_.mode1[0] = 1;
+  EXPECT_FALSE(ValidateCodeTable());
+}
+
+TEST_F(CodeTableTest, NoOpWithNonzeroMode) {
+  VerifyInstruction(/* opcode */ 20, VCD_COPY, /* size */ 4, /* mode */ 0);
+  code_table_data_.inst1[20] = VCD_NOOP;
+  code_table_data_.mode1[20] = 0;
+  code_table_data_.size1[20] = 0;
+  EXPECT_TRUE(ValidateCodeTable());
+  code_table_data_.mode1[20] = 1;
+  EXPECT_FALSE(ValidateCodeTable());
+}
+
+TEST_F(CodeTableTest, NoOpWithNonzeroSize) {
+  VerifyInstruction(/* opcode */ 20, VCD_COPY, /* size */ 4, /* mode */ 0);
+  code_table_data_.inst1[20] = VCD_NOOP;
+  code_table_data_.mode1[20] = 0;
+  code_table_data_.size1[20] = 0;
+  EXPECT_TRUE(ValidateCodeTable());
+  code_table_data_.size1[20] = 1;
+  EXPECT_FALSE(ValidateCodeTable());
+}
+
+TEST_F(CodeTableTest, BadSecondOpcode) {
+  VerifyInstruction(/* opcode */ 20, VCD_COPY, /* size */ 4, /* mode */ 0);
+  code_table_data_.inst2[20] = VCD_LAST_INSTRUCTION_TYPE + 1;
+  EXPECT_FALSE(ValidateCodeTable());
+  code_table_data_.inst2[20] = 0xFF;
+  EXPECT_FALSE(ValidateCodeTable());
+}
+
+TEST_F(CodeTableTest, BadSecondMode) {
+  VerifyInstruction(/* opcode */ 20, VCD_COPY, /* size */ 4, /* mode */ 0);
+  code_table_data_.inst2[20] = VCD_COPY;
+  EXPECT_TRUE(ValidateCodeTable());
+  code_table_data_.mode2[20] = VCDiffAddressCache::DefaultLastMode() + 1;
+  EXPECT_FALSE(ValidateCodeTable());
+  code_table_data_.mode2[20] = 0xFF;
+  EXPECT_FALSE(ValidateCodeTable());
+}
+
+TEST_F(CodeTableTest, AddSecondWithNonzeroMode) {
+  VerifyInstruction(/* opcode */ 20, VCD_COPY, /* size */ 4, /* mode */ 0);
+  code_table_data_.inst2[20] = VCD_ADD;
+  EXPECT_TRUE(ValidateCodeTable());
+  code_table_data_.mode2[20] = 1;
+  EXPECT_FALSE(ValidateCodeTable());
+}
+
+TEST_F(CodeTableTest, RunSecondWithNonzeroMode) {
+  VerifyInstruction(/* opcode */ 20, VCD_COPY, /* size */ 4, /* mode */ 0);
+  code_table_data_.inst2[20] = VCD_RUN;
+  EXPECT_TRUE(ValidateCodeTable());
+  code_table_data_.mode2[20] = 1;
+  EXPECT_FALSE(ValidateCodeTable());
+}
+
+TEST_F(CodeTableTest, SecondNoOpWithNonzeroMode) {
+  VerifyInstruction(/* opcode */ 20, VCD_COPY, /* size */ 4, /* mode */ 0);
+  EXPECT_EQ(VCD_NOOP, code_table_data_.inst2[20]);
+  code_table_data_.mode2[20] = 1;
+  EXPECT_FALSE(ValidateCodeTable());
+}
+
+TEST_F(CodeTableTest, SecondNoOpWithNonzeroSize) {
+  VerifyInstruction(/* opcode */ 20, VCD_COPY, /* size */ 4, /* mode */ 0);
+  EXPECT_EQ(VCD_NOOP, code_table_data_.inst2[20]);
+  code_table_data_.size2[20] = 1;
+  EXPECT_FALSE(ValidateCodeTable());
+}
+
+TEST_F(CodeTableTest, ValidateExerciseCodeTable) {
+  EXPECT_TRUE(g_exercise_code_table_->Validate(kLastExerciseMode));
+}
+
+}  // unnamed namespace
+}  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/compile_assert.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/compile_assert.h
new file mode 100644
index 0000000..f4ba293
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/compile_assert.h
@@ -0,0 +1,78 @@
+// Copyright 2008 Google Inc.
+// Authors: Zhanyong Wan, Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OPEN_VCDIFF_COMPILE_ASSERT_H_
+#define OPEN_VCDIFF_COMPILE_ASSERT_H_
+
+#include <config.h>
+
+// The COMPILE_ASSERT macro can be used to verify that a compile-time
+// expression is true. For example, you could use it to verify the
+// size of a static array:
+//
+//   COMPILE_ASSERT(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES,
+//                  content_type_names_incorrect_size);
+//
+// or to make sure a struct is smaller than a certain size:
+//
+//   COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large);
+//
+// For the second argument to COMPILE_ASSERT, the programmer should supply
+// a variable name that meets C++ naming rules, but that provides
+// a description of the compile-time rule that has been violated.
+// (In the example above, the name used is "foo_too_large".)
+// If the expression is false, most compilers will issue a warning/error
+// containing the name of the variable.
+// This refinement (adding a descriptive variable name argument)
+// is what differentiates COMPILE_ASSERT from Boost static asserts.
+
+template <bool>
+struct CompileAssert {
+};
+
+#define COMPILE_ASSERT(expr, msg) \
+  typedef CompileAssert<static_cast<bool>(expr)> \
+      msg[static_cast<bool>(expr) ? 1 : -1]
+
+// Implementation details of COMPILE_ASSERT:
+//
+// - COMPILE_ASSERT works by defining an array type that has -1
+//   elements (and thus is invalid) when the expression is false.
+//
+// - The simpler definition
+//
+//     #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1]
+//
+//   does not work, as gcc supports variable-length arrays whose sizes
+//   are determined at run-time (this is gcc's extension and not part
+//   of the C++ standard).  As a result, gcc fails to reject the
+//   following code with the simple definition:
+//
+//     int foo;
+//     COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is
+//                               // not a compile-time constant.
+//
+// - By using the type CompileAssert<(static_cast<bool>(expr))>, we ensure that
+//   expr is a compile-time constant.  (Template arguments must be
+//   determined at compile-time.)
+//
+// - The array size is (static_cast<bool>(expr) ? 1 : -1), instead of simply
+//
+//     ((expr) ? 1 : -1).
+//
+//   This is to avoid running into a bug in MS VC 7.1, which
+//   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
+
+#endif  // OPEN_VCDIFF_COMPILE_ASSERT_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/config.h.in b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/config.h.in
new file mode 100644
index 0000000..f0ae1c6
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/config.h.in
@@ -0,0 +1,122 @@
+/* src/config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#undef HAVE_DLFCN_H
+
+/* Define to 1 if you have the <ext/rope> header file. */
+#undef HAVE_EXT_ROPE
+
+/* Define to 1 if you have the <fnmatch.h> header file. */
+#undef HAVE_FNMATCH_H
+
+/* Define to 1 if you have the <getopt.h> header file. */
+#undef HAVE_GETOPT_H
+
+/* Define to 1 if you have the `gettimeofday' function. */
+#undef HAVE_GETTIMEOFDAY
+
+/* Define to 1 if you have the `InitializeCriticalSection' function. */
+#undef HAVE_INITIALIZECRITICALSECTION
+
+/* Define to 1 if you have the `InterlockedCompareExchange' function. */
+#undef HAVE_INTERLOCKEDCOMPAREEXCHANGE
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#undef HAVE_INTTYPES_H
+
+/* Define to 1 if you have the <malloc.h> header file. */
+#undef HAVE_MALLOC_H
+
+/* Define to 1 if you have the `memalign' function. */
+#undef HAVE_MEMALIGN
+
+/* Define to 1 if you have the <memory.h> header file. */
+#undef HAVE_MEMORY_H
+
+/* Define to 1 if you have the `mprotect' function. */
+#undef HAVE_MPROTECT
+
+/* Define to 1 if you have the `posix_memalign' function. */
+#undef HAVE_POSIX_MEMALIGN
+
+/* Define if you have POSIX threads libraries and header files. */
+#undef HAVE_PTHREAD
+
+/* Define to 1 if you have the `QueryPerformanceCounter' function. */
+#undef HAVE_QUERYPERFORMANCECOUNTER
+
+/* 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 `strtoll' function. */
+#undef HAVE_STRTOLL
+
+/* Define to 1 if you have the `strtoq' function. */
+#undef HAVE_STRTOQ
+
+/* 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/stat.h> header file. */
+#undef HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/time.h> header file. */
+#undef HAVE_SYS_TIME_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#undef HAVE_SYS_TYPES_H
+
+/* Define to 1 if the system has the type `uint16_t'. */
+#undef HAVE_UINT16_T
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#undef HAVE_UNISTD_H
+
+/* Define to 1 if the system has the type `u_int16_t'. */
+#undef HAVE_U_INT16_T
+
+/* Define to 1 if you have the <windows.h> header file. */
+#undef HAVE_WINDOWS_H
+
+/* define if your compiler has __attribute__ */
+#undef HAVE___ATTRIBUTE__
+
+/* Define to 1 if the system has the type `__int16'. */
+#undef HAVE___INT16
+
+/* 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 version of this package. */
+#undef PACKAGE_VERSION
+
+/* Define to necessary symbol if this constant uses a non-standard name on
+   your system. */
+#undef PTHREAD_CREATE_JOINABLE
+
+/* Define to 1 if you have the ANSI C header files. */
+#undef STDC_HEADERS
+
+/* Version number of package */
+#undef VERSION
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/decodetable.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/decodetable.cc
new file mode 100644
index 0000000..ebcec6b
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/decodetable.cc
@@ -0,0 +1,114 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// VCDiffCodeTableReader is a class to interpret a stream of opcodes
+// as VCDIFF instruction types, based on a VCDiffCodeTableData structure.
+
+#include <config.h>
+#include "decodetable.h"
+#include "codetable.h"
+#include "logging.h"
+#include "varint_bigendian.h"
+#include "vcdiff_defs.h"
+
+namespace open_vcdiff {
+
+VCDiffCodeTableReader::VCDiffCodeTableReader()
+    : code_table_data_(&VCDiffCodeTableData::kDefaultCodeTableData),
+      non_default_code_table_data_(NULL),
+      instructions_and_sizes_(NULL),
+      instructions_and_sizes_end_(NULL),
+      last_instruction_start_(NULL),
+      pending_second_instruction_(kNoOpcode),
+      last_pending_second_instruction_(kNoOpcode) {
+}
+
+bool VCDiffCodeTableReader::UseCodeTable(
+    const VCDiffCodeTableData& code_table_data, unsigned char max_mode) {
+  if (!code_table_data.Validate(max_mode)) return false;
+  if (!non_default_code_table_data_.get()) {
+    non_default_code_table_data_.reset(new VCDiffCodeTableData);
+  }
+  *non_default_code_table_data_ = code_table_data;
+  code_table_data_ = non_default_code_table_data_.get();
+  return true;
+}
+
+VCDiffInstructionType VCDiffCodeTableReader::GetNextInstruction(
+    int32_t* size,
+    unsigned char* mode) {
+  if (!instructions_and_sizes_) {
+    LOG(ERROR) << "Internal error: GetNextInstruction() called before Init()"
+               << LOG_ENDL;
+    return VCD_INSTRUCTION_ERROR;
+  }
+  last_instruction_start_ = *instructions_and_sizes_;
+  last_pending_second_instruction_ = pending_second_instruction_;
+  unsigned char opcode = 0;
+  unsigned char instruction_type = VCD_NOOP;
+  int32_t instruction_size = 0;
+  unsigned char instruction_mode = 0;
+  do {
+    if (pending_second_instruction_ != kNoOpcode) {
+      // There is a second instruction left over
+      // from the most recently processed opcode.
+      opcode = static_cast<unsigned char>(pending_second_instruction_);
+      pending_second_instruction_ = kNoOpcode;
+      instruction_type = code_table_data_->inst2[opcode];
+      instruction_size = code_table_data_->size2[opcode];
+      instruction_mode = code_table_data_->mode2[opcode];
+      break;
+    }
+    if (*instructions_and_sizes_ >= instructions_and_sizes_end_) {
+      // Ran off end of instruction stream
+      return VCD_INSTRUCTION_END_OF_DATA;
+    }
+    opcode = **instructions_and_sizes_;
+    if (code_table_data_->inst2[opcode] != VCD_NOOP) {
+      // This opcode contains two instructions; process the first one now, and
+      // save a pointer to the second instruction, which should be returned
+      // by the next call to GetNextInstruction
+      pending_second_instruction_ = **instructions_and_sizes_;
+    }
+    ++(*instructions_and_sizes_);
+    instruction_type = code_table_data_->inst1[opcode];
+    instruction_size = code_table_data_->size1[opcode];
+    instruction_mode = code_table_data_->mode1[opcode];
+  // This do-while loop is necessary in case inst1 == VCD_NOOP for an opcode
+  // that was actually used in the encoding.  That case is unusual, but it
+  // is not prohibited by the standard.
+  } while (instruction_type == VCD_NOOP);
+  if (instruction_size == 0) {
+    // Parse the size as a Varint in the instruction stream.
+    switch (*size = VarintBE<int32_t>::Parse(instructions_and_sizes_end_,
+                                             instructions_and_sizes_)) {
+      case RESULT_ERROR:
+        LOG(ERROR) << "Instruction size is not a valid variable-length integer"
+                   << LOG_ENDL;
+        return VCD_INSTRUCTION_ERROR;
+      case RESULT_END_OF_DATA:
+        UnGetInstruction();  // Rewind to instruction start
+        return VCD_INSTRUCTION_END_OF_DATA;
+      default:
+        break;  // Successfully parsed Varint
+    }
+  } else {
+    *size = instruction_size;
+  }
+  *mode = instruction_mode;
+  return static_cast<VCDiffInstructionType>(instruction_type);
+}
+
+};  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/decodetable.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/decodetable.h
new file mode 100644
index 0000000..3ba997a
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/decodetable.h
@@ -0,0 +1,152 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OPEN_VCDIFF_DECODETABLE_H_
+#define OPEN_VCDIFF_DECODETABLE_H_
+
+#include <config.h>
+#include <stdint.h>     // int32_t
+#include <cstddef>      // NULL
+#include <memory>       // auto_ptr
+#include "codetable.h"  // VCDiffInstructi...
+#include "logging.h"
+
+namespace open_vcdiff {
+
+// This class is used by the decoder.  It can use a standard or
+// non-standard code table, and will translate the opcodes in the code table
+// into delta instructions.
+//
+// NOT threadsafe.
+//
+class VCDiffCodeTableReader {
+ public:
+  // When constructed, the object will be set up to use the default code table.
+  // If a non-default code table is to be used, then UseCodeTable()
+  // should be called after the VCDiffCodeTableReader has been constructed.
+  // In any case, the Init() method must be called before GetNextInstruction()
+  // may be used.
+  //
+  VCDiffCodeTableReader();
+
+  // Sets up a non-standard code table.  The caller
+  // may free the memory occupied by the argument code table after
+  // passing it to this method, because the argument code table
+  // allocates space to store a copy of it.
+  // UseCodeTable() may be called either before or after calling Init().
+  // Returns true if the code table was accepted, or false if the
+  // argument did not appear to be a valid code table.
+  //
+  bool UseCodeTable(const VCDiffCodeTableData& code_table_data,
+                    unsigned char max_mode);
+
+  // Defines the buffer containing the instructions and sizes.
+  // This method must be called before GetNextInstruction() may be used.
+  // Init() may be called any number of times to reset the state of
+  // the object.
+  //
+  void Init(const char** instructions_and_sizes,
+            const char* instructions_and_sizes_end) {
+    instructions_and_sizes_ = instructions_and_sizes;
+    instructions_and_sizes_end_ = instructions_and_sizes_end;
+    last_instruction_start_ = NULL;
+    pending_second_instruction_ = kNoOpcode;
+    last_pending_second_instruction_ = kNoOpcode;
+  }
+
+  // Updates the pointers to the buffer containing the instructions and sizes,
+  // but leaves the rest of the reader state intact, so that (for example)
+  // any pending second instruction or unread instruction will still be
+  // read when requested.  NOTE: UnGetInstruction() will not work immediately
+  // after using UpdatePointers(); GetNextInstruction() must be called first.
+  //
+  void UpdatePointers(const char** instructions_and_sizes,
+                      const char* instructions_and_sizes_end) {
+    instructions_and_sizes_ = instructions_and_sizes;
+    instructions_and_sizes_end_ = instructions_and_sizes_end;
+    last_instruction_start_ = *instructions_and_sizes;
+    // pending_second_instruction_ is unchanged
+    last_pending_second_instruction_ = pending_second_instruction_;
+  }
+
+  // Returns the next instruction from the stream of opcodes,
+  // or VCD_INSTRUCTION_END_OF_DATA if the end of the opcode stream is reached,
+  // or VCD_INSTRUCTION_ERROR if an error occurred.
+  // In the first of these cases, increments *instructions_and_sizes_
+  // past the values it reads, and populates *size
+  // with the corresponding size for the returned instruction;
+  // otherwise, the value of *size is undefined, and is not
+  // guaranteed to be preserved.
+  // If the instruction returned is VCD_COPY, *mode will
+  // be populated with the copy mode; otherwise, the value of *mode
+  // is undefined, and is not guaranteed to be preserved.
+  // Any occurrences of VCD_NOOP in the opcode stream
+  // are skipped over and ignored, not returned.
+  // If Init() was not called before calling this method, then
+  // VCD_INSTRUCTION_ERROR will be returned.
+  //
+  VCDiffInstructionType GetNextInstruction(int32_t* size, unsigned char* mode);
+
+  // Puts a single instruction back onto the front of the
+  // instruction stream.  The next call to GetNextInstruction()
+  // will return the same value that was returned by the last
+  // call.  Calling UnGetInstruction() more than once before calling
+  // GetNextInstruction() will have no additional effect; you can
+  // only rewind one instruction.
+  //
+  void UnGetInstruction() {
+    if (last_instruction_start_) {
+      if (last_instruction_start_ > *instructions_and_sizes_) {
+        LOG(DFATAL) << "Internal error: last_instruction_start past end of "
+                       "instructions_and_sizes in UnGetInstruction" << LOG_ENDL;
+      }
+      *instructions_and_sizes_ = last_instruction_start_;
+      if ((pending_second_instruction_ != kNoOpcode) &&
+          (last_pending_second_instruction_ != kNoOpcode)) {
+        LOG(DFATAL) << "Internal error: two pending instructions in a row "
+                       "in UnGetInstruction" << LOG_ENDL;
+      }
+      pending_second_instruction_ = last_pending_second_instruction_;
+    }
+  }
+
+ private:
+  // A pointer to the code table.  This is the object that will be used
+  // to interpret opcodes in GetNextInstruction().
+  const VCDiffCodeTableData* code_table_data_;
+
+  // If the default code table is not being used, then space for the
+  // code table data will be allocated using this pointer and freed
+  // when the VCDiffCodeTableReader is destroyed.  This will keep the
+  // code that uses the object from having to worry about memory
+  // management for the non-standard code table, whose contents have
+  // been read as part of the encoded data file/stream.
+  //
+  std::auto_ptr<VCDiffCodeTableData> non_default_code_table_data_;
+
+  const char** instructions_and_sizes_;
+  const char* instructions_and_sizes_end_;
+  const char* last_instruction_start_;
+  OpcodeOrNone pending_second_instruction_;
+  OpcodeOrNone last_pending_second_instruction_;
+
+  // Making these private avoids implicit copy constructor & assignment operator
+  VCDiffCodeTableReader(const VCDiffCodeTableReader&);
+  void operator=(const VCDiffCodeTableReader&);
+};
+
+};  // namespace open_vcdiff
+
+#endif  // OPEN_VCDIFF_DECODETABLE_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/decodetable_test.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/decodetable_test.cc
new file mode 100644
index 0000000..214cb52
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/decodetable_test.cc
@@ -0,0 +1,464 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Unit tests for the class VCDiffCodeTableReader, found in decodetable.h.
+
+#include <config.h>
+#include "decodetable.h"
+#include <stdint.h>  // int32_t
+#include <vector>
+#include "addrcache.h"
+#include "codetable.h"
+#include "testing.h"
+#include "varint_bigendian.h"
+
+namespace open_vcdiff {
+namespace {
+
+class DecodeTableTest : public testing::Test {
+ protected:
+  DecodeTableTest()
+  : instructions_and_sizes_(instruction_buffer_size),
+    found_size_(0),
+    found_mode_(0) {
+    instructions_and_sizes_ptr_ = &instructions_and_sizes_[0];
+    reader_.Init(&instructions_and_sizes_ptr_,
+                 instructions_and_sizes_ptr_ + instruction_buffer_size);
+  }
+
+  static void AddExerciseOpcode(unsigned char inst1,
+                                unsigned char mode1,
+                                unsigned char size1,
+                                unsigned char inst2,
+                                unsigned char mode2,
+                                unsigned char size2,
+                                int opcode) {
+    g_exercise_code_table_->inst1[opcode] = inst1;
+    g_exercise_code_table_->mode1[opcode] = mode1;
+    g_exercise_code_table_->size1[opcode] = (inst1 == VCD_NOOP) ? 0 : size1;
+    g_exercise_code_table_->inst2[opcode] = inst2;
+    g_exercise_code_table_->mode2[opcode] = mode2;
+    g_exercise_code_table_->size2[opcode] = (inst2 == VCD_NOOP) ? 0 : size2;
+  }
+
+  static void SetUpTestCase() {
+    g_exercise_code_table_ = new VCDiffCodeTableData;
+    int opcode = 0;
+    for (unsigned char inst_mode1 = 0;
+         inst_mode1 <= VCD_LAST_INSTRUCTION_TYPE + kLastExerciseMode;
+         ++inst_mode1) {
+      unsigned char inst1 = inst_mode1;
+      unsigned char mode1 = 0;
+      if (inst_mode1 > VCD_COPY) {
+        inst1 = VCD_COPY;
+        mode1 = inst_mode1 - VCD_COPY;
+      }
+      for (unsigned char inst_mode2 = 0;
+           inst_mode2 <= VCD_LAST_INSTRUCTION_TYPE + kLastExerciseMode;
+           ++inst_mode2) {
+        unsigned char inst2 = inst_mode2;
+        unsigned char mode2 = 0;
+        if (inst_mode2 > VCD_COPY) {
+          inst2 = VCD_COPY;
+          mode2 = inst_mode2 - VCD_COPY;
+        }
+        AddExerciseOpcode(inst1, mode1, 0, inst2, mode2, 0, opcode++);
+        AddExerciseOpcode(inst1, mode1, 0, inst2, mode2, 255, opcode++);
+        AddExerciseOpcode(inst1, mode1, 255, inst2, mode2, 0, opcode++);
+        AddExerciseOpcode(inst1, mode1, 255, inst2, mode2, 255, opcode++);
+      }
+    }
+    if (VCDiffCodeTableData::kCodeTableSize != opcode) {
+      LOG(FATAL) << "Internal error in test: The nested loops in "
+                    "DecodeTableTest::SetUpTestCase should iterate through "
+                    "exactly " << VCDiffCodeTableData::kCodeTableSize
+                 << " opcodes.";
+      return;
+    }
+    EXPECT_TRUE(VCDiffCodeTableData::kDefaultCodeTableData.Validate());
+    EXPECT_TRUE(g_exercise_code_table_->Validate(kLastExerciseMode));
+  }
+
+  static void TearDownTestCase() {
+    delete g_exercise_code_table_;
+  }
+
+  void VerifyInstModeSize(unsigned char inst,
+                          unsigned char mode,
+                          unsigned char size,
+                          unsigned char opcode) {
+    if (inst == VCD_NOOP) return;  // GetNextInstruction skips NOOPs
+    int32_t found_size = 0;
+    unsigned char found_mode = 0;
+    unsigned char found_inst = reader_.GetNextInstruction(&found_size,
+                                                          &found_mode);
+    EXPECT_EQ(inst, found_inst);
+    EXPECT_EQ(mode, found_mode);
+    if (size == 0) {
+      EXPECT_EQ(1000 + opcode, found_size);
+    } else {
+      EXPECT_EQ(size, found_size);
+    }
+  }
+
+  void VerifyInstModeSize1(unsigned char inst,
+                           unsigned char mode,
+                           unsigned char size,
+                           unsigned char opcode) {
+    if (inst == VCD_NOOP) size = 0;
+    EXPECT_EQ(g_exercise_code_table_->inst1[opcode], inst);
+    EXPECT_EQ(g_exercise_code_table_->mode1[opcode], mode);
+    EXPECT_EQ(g_exercise_code_table_->size1[opcode], size);
+    VerifyInstModeSize(inst, mode, size, opcode);
+  }
+
+  void VerifyInstModeSize2(unsigned char inst,
+                           unsigned char mode,
+                           unsigned char size,
+                           unsigned char opcode) {
+    if (inst == VCD_NOOP) size = 0;
+    EXPECT_EQ(g_exercise_code_table_->inst2[opcode], inst);
+    EXPECT_EQ(g_exercise_code_table_->mode2[opcode], mode);
+    EXPECT_EQ(g_exercise_code_table_->size2[opcode], size);
+    VerifyInstModeSize(inst, mode, size, opcode);
+  }
+
+  // This value is designed so that the total number of inst values and modes
+  // will equal 8 (VCD_NOOP, VCD_ADD, VCD_RUN, VCD_COPY modes 0 - 4).
+  // Eight combinations of inst and mode, times two possible size values,
+  // squared (because there are two instructions per opcode), makes
+  // exactly 256 possible instruction combinations, which fits kCodeTableSize
+  // (the number of opcodes in the table.)
+  static const int kLastExerciseMode = 4;
+
+  // The buffer size (in bytes) needed to store kCodeTableSize opcodes plus
+  // up to kCodeTableSize VarintBE-encoded size values.
+  static const int instruction_buffer_size;
+
+  // A code table that exercises as many combinations as possible:
+  // 2 instructions, each is a NOOP, ADD, RUN, or one of 5 copy modes
+  // (== 8 total combinations of inst and mode), and each has
+  // size == 0 or 255 (2 possibilities.)
+  static VCDiffCodeTableData* g_exercise_code_table_;
+
+  VCDiffCodeTableReader reader_;
+
+  // A buffer to which instructions and sizes will be added manually
+  // in order to exercise VCDiffCodeTableReader.
+  std::vector<char> instructions_and_sizes_;
+
+  // The buffer pointer used by the VCDiffCodeTableReader.
+  const char* instructions_and_sizes_ptr_;
+
+  // The size and mode returned by GetNextInstruction().
+  int32_t found_size_;
+  unsigned char found_mode_;
+};
+
+VCDiffCodeTableData* DecodeTableTest::g_exercise_code_table_ = NULL;
+
+const int DecodeTableTest::instruction_buffer_size =
+    VCDiffCodeTableData::kCodeTableSize *
+        (1 + (VarintBE<VCDAddress>::kMaxBytes));
+
+TEST_F(DecodeTableTest, ReadAdd) {
+  instructions_and_sizes_[0] = 1;
+  VarintBE<VCDAddress>::Encode(257, &instructions_and_sizes_[1]);
+  unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
+                                                        &found_mode_);
+  EXPECT_EQ(VCD_ADD, found_inst);
+  EXPECT_EQ(257, found_size_);
+  EXPECT_EQ(0, found_mode_);
+}
+
+TEST_F(DecodeTableTest, ReadRun) {
+  instructions_and_sizes_[0] = 0;
+  VarintBE<VCDAddress>::Encode(111, &instructions_and_sizes_[1]);
+  unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
+                                                        &found_mode_);
+  EXPECT_EQ(VCD_RUN, found_inst);
+  EXPECT_EQ(111, found_size_);
+  EXPECT_EQ(0, found_mode_);
+}
+
+TEST_F(DecodeTableTest, ReadCopy) {
+  instructions_and_sizes_[0] = 58;
+  instructions_and_sizes_[1] = 0;
+  unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
+                                                        &found_mode_);
+  EXPECT_EQ(VCD_COPY, found_inst);
+  EXPECT_EQ(10, found_size_);
+  EXPECT_EQ(2, found_mode_);
+}
+
+TEST_F(DecodeTableTest, ReadAddCopy) {
+  instructions_and_sizes_[0] = 175;
+  instructions_and_sizes_[1] = 0;
+  unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
+                                                        &found_mode_);
+  EXPECT_EQ(VCD_ADD, found_inst);
+  EXPECT_EQ(1, found_size_);
+  EXPECT_EQ(0, found_mode_);
+  found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
+  EXPECT_EQ(VCD_COPY, found_inst);
+  EXPECT_EQ(4, found_size_);
+  EXPECT_EQ(1, found_mode_);
+}
+
+TEST_F(DecodeTableTest, ReadCopyAdd) {
+  instructions_and_sizes_[0] = 255;
+  instructions_and_sizes_[1] = 0;
+  unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
+                                                        &found_mode_);
+  EXPECT_EQ(VCD_COPY, found_inst);
+  EXPECT_EQ(4, found_size_);
+  EXPECT_EQ(8, found_mode_);
+  found_mode_ = 0;
+  found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
+  EXPECT_EQ(VCD_ADD, found_inst);
+  EXPECT_EQ(1, found_size_);
+  EXPECT_EQ(0, found_mode_);
+}
+
+TEST_F(DecodeTableTest, UnGetAdd) {
+  instructions_and_sizes_[0] = 1;
+  instructions_and_sizes_[1] = 255;
+  VarintBE<VCDAddress>::Encode(257, &instructions_and_sizes_[1]);
+  unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
+                                                        &found_mode_);
+  EXPECT_EQ(VCD_ADD, found_inst);
+  EXPECT_EQ(257, found_size_);
+  EXPECT_EQ(0, found_mode_);
+  reader_.UnGetInstruction();
+  found_size_ = 0;
+  found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
+  EXPECT_EQ(VCD_ADD, found_inst);
+  EXPECT_EQ(257, found_size_);
+  EXPECT_EQ(0, found_mode_);
+}
+
+TEST_F(DecodeTableTest, UnGetCopy) {
+  instructions_and_sizes_[0] = 58;
+  instructions_and_sizes_[1] = 0;
+  instructions_and_sizes_[2] = 255;
+  unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
+                                                        &found_mode_);
+  EXPECT_EQ(VCD_COPY, found_inst);
+  EXPECT_EQ(10, found_size_);
+  EXPECT_EQ(2, found_mode_);
+  reader_.UnGetInstruction();
+  found_size_ = 0;
+  found_mode_ = 0;
+  found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
+  EXPECT_EQ(VCD_COPY, found_inst);
+  EXPECT_EQ(10, found_size_);
+  EXPECT_EQ(2, found_mode_);
+}
+
+TEST_F(DecodeTableTest, UnGetCopyAdd) {
+  instructions_and_sizes_[0] = 255;
+  instructions_and_sizes_[1] = 0;
+  unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
+                                                        &found_mode_);
+  EXPECT_EQ(VCD_COPY, found_inst);
+  EXPECT_EQ(4, found_size_);
+  EXPECT_EQ(8, found_mode_);
+  reader_.UnGetInstruction();
+  found_mode_ = 0;
+  found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
+  EXPECT_EQ(VCD_COPY, found_inst);
+  EXPECT_EQ(4, found_size_);
+  EXPECT_EQ(8, found_mode_);
+  found_mode_ = 0;
+  found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
+  EXPECT_EQ(VCD_ADD, found_inst);
+  EXPECT_EQ(1, found_size_);
+  EXPECT_EQ(0, found_mode_);
+}
+
+TEST_F(DecodeTableTest, UnGetTwice) {
+  instructions_and_sizes_[0] = 255;
+  instructions_and_sizes_[1] = 0;
+  unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
+                                                        &found_mode_);
+  EXPECT_EQ(VCD_COPY, found_inst);
+  EXPECT_EQ(4, found_size_);
+  EXPECT_EQ(8, found_mode_);
+  reader_.UnGetInstruction();
+  reader_.UnGetInstruction();
+  found_mode_ = 0;
+  found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
+  EXPECT_EQ(VCD_COPY, found_inst);
+  EXPECT_EQ(4, found_size_);
+  EXPECT_EQ(8, found_mode_);
+  found_mode_ = 0;
+  found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
+  EXPECT_EQ(VCD_ADD, found_inst);
+  EXPECT_EQ(1, found_size_);
+  EXPECT_EQ(0, found_mode_);
+}
+
+TEST_F(DecodeTableTest, UnGetBeforeGet) {
+  instructions_and_sizes_[0] = 255;
+  instructions_and_sizes_[1] = 0;
+  reader_.UnGetInstruction();
+  unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
+                                                        &found_mode_);
+  EXPECT_EQ(VCD_COPY, found_inst);
+  EXPECT_EQ(4, found_size_);
+  EXPECT_EQ(8, found_mode_);
+}
+
+TEST_F(DecodeTableTest, UnGetAddCopy) {
+  instructions_and_sizes_[0] = 175;
+  instructions_and_sizes_[1] = 0;
+  unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
+                                                        &found_mode_);
+  EXPECT_EQ(VCD_ADD, found_inst);
+  EXPECT_EQ(1, found_size_);
+  EXPECT_EQ(0, found_mode_);
+  reader_.UnGetInstruction();
+  found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
+  EXPECT_EQ(VCD_ADD, found_inst);
+  EXPECT_EQ(1, found_size_);
+  EXPECT_EQ(0, found_mode_);
+  found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
+  EXPECT_EQ(VCD_COPY, found_inst);
+  EXPECT_EQ(4, found_size_);
+  EXPECT_EQ(1, found_mode_);
+}
+
+TEST_F(DecodeTableTest, ReReadIncomplete) {
+  instructions_and_sizes_[0] = 175;  // Add(1) + Copy1(4)
+  instructions_and_sizes_[1] = 1;    // Add(0)
+  instructions_and_sizes_[2] = 111;  // with size 111
+  instructions_and_sizes_[3] = 255;  // Copy8(4) + Add(1)
+
+  reader_.Init(&instructions_and_sizes_ptr_,
+               instructions_and_sizes_ptr_ + 0);  // 0 bytes available
+  EXPECT_EQ(VCD_INSTRUCTION_END_OF_DATA,
+            reader_.GetNextInstruction(&found_size_, &found_mode_));
+  EXPECT_EQ(&instructions_and_sizes_[0], instructions_and_sizes_ptr_);
+
+  reader_.Init(&instructions_and_sizes_ptr_,
+              instructions_and_sizes_ptr_ + 1);  // 1 more byte available
+  EXPECT_EQ(VCD_ADD, reader_.GetNextInstruction(&found_size_, &found_mode_));
+  EXPECT_EQ(1, found_size_);
+  EXPECT_EQ(0, found_mode_);
+  EXPECT_EQ(VCD_COPY, reader_.GetNextInstruction(&found_size_, &found_mode_));
+  EXPECT_EQ(4, found_size_);
+  EXPECT_EQ(1, found_mode_);
+  EXPECT_EQ(VCD_INSTRUCTION_END_OF_DATA,
+            reader_.GetNextInstruction(&found_size_, &found_mode_));
+  EXPECT_EQ(&instructions_and_sizes_[1], instructions_and_sizes_ptr_);
+
+  reader_.Init(&instructions_and_sizes_ptr_,
+              instructions_and_sizes_ptr_ + 1);  // 1 more byte available
+  // The opcode is available, but the separately encoded size is not
+  EXPECT_EQ(VCD_INSTRUCTION_END_OF_DATA,
+            reader_.GetNextInstruction(&found_size_, &found_mode_));
+  EXPECT_EQ(&instructions_and_sizes_[1], instructions_and_sizes_ptr_);
+
+  reader_.Init(&instructions_and_sizes_ptr_,
+              instructions_and_sizes_ptr_ + 2);  // 2 more bytes available
+  EXPECT_EQ(VCD_ADD, reader_.GetNextInstruction(&found_size_, &found_mode_));
+  EXPECT_EQ(111, found_size_);
+  EXPECT_EQ(0, found_mode_);
+  EXPECT_EQ(VCD_INSTRUCTION_END_OF_DATA,
+            reader_.GetNextInstruction(&found_size_, &found_mode_));
+  EXPECT_EQ(&instructions_and_sizes_[3], instructions_and_sizes_ptr_);
+
+  reader_.Init(&instructions_and_sizes_ptr_,
+              instructions_and_sizes_ptr_ + 1);  // 1 more byte available
+  EXPECT_EQ(VCD_COPY, reader_.GetNextInstruction(&found_size_, &found_mode_));
+  EXPECT_EQ(4, found_size_);
+  EXPECT_EQ(8, found_mode_);
+  EXPECT_EQ(VCD_ADD, reader_.GetNextInstruction(&found_size_, &found_mode_));
+  EXPECT_EQ(1, found_size_);
+  EXPECT_EQ(0, found_mode_);
+  EXPECT_EQ(VCD_INSTRUCTION_END_OF_DATA,
+            reader_.GetNextInstruction(&found_size_, &found_mode_));
+  EXPECT_EQ(&instructions_and_sizes_[4], instructions_and_sizes_ptr_);
+}
+
+TEST_F(DecodeTableTest, ExerciseCodeTableReader) {
+  char* instruction_ptr = &instructions_and_sizes_[0];
+  for (int opcode = 0; opcode < VCDiffCodeTableData::kCodeTableSize; ++opcode) {
+    *instruction_ptr = opcode;
+    ++instruction_ptr;
+    if ((g_exercise_code_table_->inst1[opcode] != VCD_NOOP) &&
+        (g_exercise_code_table_->size1[opcode] == 0)) {
+      // A separately-encoded size value
+      int encoded_size = VarintBE<VCDAddress>::Encode(1000 + opcode,
+                                                      instruction_ptr);
+      EXPECT_LT(0, encoded_size);
+      instruction_ptr += encoded_size;
+    }
+    if ((g_exercise_code_table_->inst2[opcode] != VCD_NOOP) &&
+        (g_exercise_code_table_->size2[opcode] == 0)) {
+      int encoded_size = VarintBE<VCDAddress>::Encode(1000 + opcode,
+                                                      instruction_ptr);
+      EXPECT_LT(0, encoded_size);
+      instruction_ptr += encoded_size;
+    }
+  }
+  EXPECT_TRUE(reader_.UseCodeTable(*g_exercise_code_table_, kLastExerciseMode));
+  int opcode = 0;
+  // This loop has the same bounds as the one in SetUpTestCase.
+  // Iterate over the instruction types and make sure that the opcodes,
+  // interpreted in order, return exactly those instruction types.
+  for (unsigned char inst_mode1 = 0;
+       inst_mode1 <= VCD_LAST_INSTRUCTION_TYPE + kLastExerciseMode;
+       ++inst_mode1) {
+    unsigned char inst1 = inst_mode1;
+    unsigned char mode1 = 0;
+    if (inst_mode1 > VCD_COPY) {
+      inst1 = VCD_COPY;
+      mode1 = inst_mode1 - VCD_COPY;
+    }
+    for (unsigned char inst_mode2 = 0;
+         inst_mode2 <= VCD_LAST_INSTRUCTION_TYPE + kLastExerciseMode;
+         ++inst_mode2) {
+      unsigned char inst2 = inst_mode2;
+      unsigned char mode2 = 0;
+      if (inst_mode2 > VCD_COPY) {
+        inst2 = VCD_COPY;
+        mode2 = inst_mode2 - VCD_COPY;
+      }
+      VerifyInstModeSize1(inst1, mode1, 0, opcode);
+      VerifyInstModeSize2(inst2, mode2, 0, opcode);
+      ++opcode;
+      VerifyInstModeSize1(inst1, mode1, 0, opcode);
+      VerifyInstModeSize2(inst2, mode2, 255, opcode);
+      ++opcode;
+      VerifyInstModeSize1(inst1, mode1, 255, opcode);
+      VerifyInstModeSize2(inst2, mode2, 0, opcode);
+      ++opcode;
+      VerifyInstModeSize1(inst1, mode1, 255, opcode);
+      VerifyInstModeSize2(inst2, mode2, 255, opcode);
+      ++opcode;
+    }
+  }
+  if (VCDiffCodeTableData::kCodeTableSize != opcode) {
+    LOG(FATAL) << "Internal error in test: The nested loops in "
+                  "DecodeTableTest::ExerciseCodeTableReader should iterate "
+                  "through exactly " << VCDiffCodeTableData::kCodeTableSize
+               << " opcodes.";
+    return;
+  }
+}
+
+}  // unnamed namespace
+}  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/encodetable.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/encodetable.cc
new file mode 100644
index 0000000..5bc969d
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/encodetable.cc
@@ -0,0 +1,537 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <config.h>
+#include "encodetable.h"
+#include <string>
+#include "addrcache.h"
+#include "logging.h"
+#include "google/output_string.h"
+#include "varint_bigendian.h"
+#include "vcdiff_defs.h"
+
+namespace open_vcdiff {
+
+using std::string;
+
+// VCDiffInstructionMap members and methods
+
+VCDiffInstructionMap* VCDiffInstructionMap::default_instruction_map = NULL;
+
+VCDiffInstructionMap* VCDiffInstructionMap::GetDefaultInstructionMap() {
+  if (!default_instruction_map) {
+    default_instruction_map = new VCDiffInstructionMap(
+        VCDiffCodeTableData::kDefaultCodeTableData,
+        VCDiffAddressCache::DefaultLastMode());
+  }
+  return default_instruction_map;
+}
+
+static unsigned char FindMaxSize(
+    const unsigned char size_array[VCDiffCodeTableData::kCodeTableSize]) {
+  unsigned char max_size = size_array[0];
+  for (int i = 1; i < VCDiffCodeTableData::kCodeTableSize; ++i) {
+    if (size_array[i] > max_size) {
+      max_size = size_array[i];
+    }
+  }
+  return max_size;
+}
+
+static void ClearSizeOpcodeArray(int length, OpcodeOrNone* array) {
+  for (int i = 0; i < length; ++i) {
+    array[i] = kNoOpcode;
+  }
+}
+
+static OpcodeOrNone* NewSizeOpcodeArray(int length) {
+  OpcodeOrNone* array = new OpcodeOrNone[length];
+  ClearSizeOpcodeArray(length, array);
+  return array;
+}
+
+VCDiffInstructionMap::FirstInstructionMap::FirstInstructionMap(
+    int num_insts_and_modes,
+    int max_size_1)
+    : num_instruction_type_modes_(num_insts_and_modes),
+      max_size_1_(max_size_1) {
+  first_opcodes_ = new OpcodeOrNone*[num_instruction_type_modes_];
+  for (int i = 0; i < num_instruction_type_modes_; ++i) {
+    // There must be at least (max_size_1_ + 1) elements in first_opcodes_
+    // because the element first_opcodes[max_size_1_] will be referenced.
+    first_opcodes_[i] = NewSizeOpcodeArray(max_size_1_ + 1);
+  }
+}
+
+VCDiffInstructionMap::FirstInstructionMap::~FirstInstructionMap() {
+  for (int i = 0; i < num_instruction_type_modes_; ++i) {
+    delete[] first_opcodes_[i];
+  }
+  delete[] first_opcodes_;
+}
+
+VCDiffInstructionMap::SecondInstructionMap::SecondInstructionMap(
+    int num_insts_and_modes,
+    int max_size_2)
+    : num_instruction_type_modes_(num_insts_and_modes),
+      max_size_2_(max_size_2) {
+  memset(second_opcodes_, 0, sizeof(second_opcodes_));
+}
+
+
+VCDiffInstructionMap::SecondInstructionMap::~SecondInstructionMap() {
+  for (int opcode = 0; opcode < VCDiffCodeTableData::kCodeTableSize; ++opcode) {
+    if (second_opcodes_[opcode] != NULL) {
+      for (int inst_mode = 0;
+           inst_mode < num_instruction_type_modes_;
+           ++inst_mode) {
+        // No need to check for NULL
+        delete[] second_opcodes_[opcode][inst_mode];
+      }
+      delete[] second_opcodes_[opcode];
+    }
+  }
+}
+
+void VCDiffInstructionMap::SecondInstructionMap::Add(
+    unsigned char first_opcode,
+    unsigned char inst,
+    unsigned char size,
+    unsigned char mode,
+    unsigned char second_opcode) {
+  OpcodeOrNone**& inst_mode_array = second_opcodes_[first_opcode];
+  if (!inst_mode_array) {
+    inst_mode_array = new OpcodeOrNone*[num_instruction_type_modes_];
+    memset(inst_mode_array,
+           0,
+           num_instruction_type_modes_ * sizeof(inst_mode_array[0]));
+  }
+  OpcodeOrNone*& size_array = inst_mode_array[inst + mode];
+  if (!size_array) {
+    // There must be at least (max_size_2_ + 1) elements in size_array
+    // because the element size_array[max_size_2_] will be referenced.
+    size_array = NewSizeOpcodeArray(max_size_2_ + 1);
+  }
+  if (size_array[size] == kNoOpcode) {
+    size_array[size] = second_opcode;
+  }
+}
+
+OpcodeOrNone VCDiffInstructionMap::SecondInstructionMap::Lookup(
+    unsigned char first_opcode,
+    unsigned char inst,
+    unsigned char size,
+    unsigned char mode) const {
+  if (size > max_size_2_) {
+    return kNoOpcode;
+  }
+  const OpcodeOrNone* const * const inst_mode_array =
+    second_opcodes_[first_opcode];
+  if (!inst_mode_array) {
+    return kNoOpcode;
+  }
+  int inst_mode = (inst == VCD_COPY) ? (inst + mode) : inst;
+  const OpcodeOrNone* const size_array = inst_mode_array[inst_mode];
+  if (!size_array) {
+    return kNoOpcode;
+  }
+  return size_array[size];
+}
+
+// Because a constructor should never fail, the caller must already
+// have run ValidateCodeTable() against the code table data.
+//
+VCDiffInstructionMap::VCDiffInstructionMap(
+    const VCDiffCodeTableData& code_table_data,
+    unsigned char max_mode)
+    : first_instruction_map_(VCD_LAST_INSTRUCTION_TYPE + max_mode + 1,
+                             FindMaxSize(code_table_data.size1)),
+      second_instruction_map_(VCD_LAST_INSTRUCTION_TYPE + max_mode + 1,
+                              FindMaxSize(code_table_data.size2)) {
+  // First pass to fill up first_instruction_map_
+  for (int opcode = 0; opcode < VCDiffCodeTableData::kCodeTableSize; ++opcode) {
+    if (code_table_data.inst2[opcode] == VCD_NOOP) {
+      // Single instruction.  If there is more than one opcode for the same
+      // inst, mode, and size, then the lowest-numbered opcode will always
+      // be used by the encoder, because of the descending loop.
+      first_instruction_map_.Add(code_table_data.inst1[opcode],
+                                 code_table_data.size1[opcode],
+                                 code_table_data.mode1[opcode],
+                                 opcode);
+    } else if (code_table_data.inst1[opcode] == VCD_NOOP) {
+      // An unusual case where inst1 == NOOP and inst2 == ADD, RUN, or COPY.
+      // This is valid under the standard, but unlikely to be used.
+      // Add it to the first instruction map as if inst1 and inst2 were swapped.
+      first_instruction_map_.Add(code_table_data.inst2[opcode],
+                                 code_table_data.size2[opcode],
+                                 code_table_data.mode2[opcode],
+                                 opcode);
+    }
+  }
+  // Second pass to fill up second_instruction_map_ (depends on first pass)
+  for (int opcode = 0; opcode < VCDiffCodeTableData::kCodeTableSize; ++opcode) {
+    if ((code_table_data.inst1[opcode] != VCD_NOOP) &&
+        (code_table_data.inst2[opcode] != VCD_NOOP)) {
+      // Double instruction.  Find the corresponding single instruction opcode
+      const OpcodeOrNone single_opcode =
+          LookupFirstOpcode(code_table_data.inst1[opcode],
+                            code_table_data.size1[opcode],
+                            code_table_data.mode1[opcode]);
+      if (single_opcode == kNoOpcode) continue;  // No single opcode found
+      second_instruction_map_.Add(static_cast<unsigned char>(single_opcode),
+                                  code_table_data.inst2[opcode],
+                                  code_table_data.size2[opcode],
+                                  code_table_data.mode2[opcode],
+                                  opcode);
+    }
+  }
+}
+
+// VCDiffCodeTableWriter members and methods
+
+// If interleaved is true, the encoder writes each delta file window
+// by interleaving instructions and sizes with their corresponding
+// addresses and data, rather than placing these elements into three
+// separate sections.  This facilitates providing partially
+// decoded results when only a portion of a delta file window
+// is received (e.g. when HTTP over TCP is used as the
+// transmission protocol.)  The interleaved format is
+// not consistent with the VCDIFF draft standard.
+//
+VCDiffCodeTableWriter::VCDiffCodeTableWriter(bool interleaved)
+    : max_mode_(VCDiffAddressCache::DefaultLastMode()),
+      dictionary_size_(0),
+      target_length_(0),
+      code_table_data_(&VCDiffCodeTableData::kDefaultCodeTableData),
+      instruction_map_(NULL),
+      last_opcode_index_(-1),
+      add_checksum_(false),
+      checksum_(0),
+      match_counts_(kMaxMatchSize, 0) {
+  InitSectionPointers(interleaved);
+}
+
+VCDiffCodeTableWriter::VCDiffCodeTableWriter(
+    bool interleaved,
+    int near_cache_size,
+    int same_cache_size,
+    const VCDiffCodeTableData& code_table_data,
+    unsigned char max_mode)
+    : max_mode_(max_mode),
+      address_cache_(near_cache_size, same_cache_size),
+      dictionary_size_(0),
+      target_length_(0),
+      code_table_data_(&code_table_data),
+      instruction_map_(NULL),
+      last_opcode_index_(-1),
+      add_checksum_(false),
+      checksum_(0)  {
+  InitSectionPointers(interleaved);
+}
+
+VCDiffCodeTableWriter::~VCDiffCodeTableWriter() {
+  if (code_table_data_ != &VCDiffCodeTableData::kDefaultCodeTableData) {
+    delete instruction_map_;
+  }
+}
+
+void VCDiffCodeTableWriter::InitSectionPointers(bool interleaved) {
+  if (interleaved) {
+    data_for_add_and_run_ = &instructions_and_sizes_;
+    addresses_for_copy_ = &instructions_and_sizes_;
+  } else {
+    data_for_add_and_run_ = &separate_data_for_add_and_run_;
+    addresses_for_copy_ = &separate_addresses_for_copy_;
+  }
+}
+
+bool VCDiffCodeTableWriter::Init(size_t dictionary_size) {
+  dictionary_size_ = dictionary_size;
+  if (!instruction_map_) {
+    if (code_table_data_ == &VCDiffCodeTableData::kDefaultCodeTableData) {
+      instruction_map_ = VCDiffInstructionMap::GetDefaultInstructionMap();
+    } else {
+      instruction_map_ = new VCDiffInstructionMap(*code_table_data_, max_mode_);
+    }
+    if (!instruction_map_) {
+      return false;
+    }
+  }
+  if (!address_cache_.Init()) {
+    return false;
+  }
+  target_length_ = 0;
+  last_opcode_index_ = -1;
+  return true;
+}
+
+// The VCDiff format allows each opcode to represent either
+// one or two delta instructions.  This function will first
+// examine the opcode generated by the last call to EncodeInstruction.
+// If that opcode was a single-instruction opcode, this function checks
+// whether there is a compound (double-instruction) opcode that can
+// combine that single instruction with the instruction that is now
+// being added, and so save a byte of space.  In that case, the
+// single-instruction opcode at position last_opcode_index_ will be
+// overwritten with the new double-instruction opcode.
+//
+// In the majority of cases, no compound opcode will be possible,
+// and a new single-instruction opcode will be appended to
+// instructions_and_sizes_, followed by a representation of its size
+// if the opcode does not implicitly give the instruction size.
+//
+// As an example, say instructions_and_sizes_ contains 10 bytes, the last
+// of which contains the opcode 0x02 (ADD size 1).  Because that was the
+// most recently added opcode, last_opcode_index_ has the value 10.
+// EncodeInstruction is then called with inst = VCD_COPY, size = 4, mode = 0.
+// The function will replace the old opcode 0x02 with the double-instruction
+// opcode 0xA3 (ADD size 1 + COPY size 4 mode 0).
+//
+// All of the double-instruction opcodes in the standard code table
+// have implicit sizes, meaning that the size of the instruction will not
+// need to be written to the instructions_and_sizes_ string separately
+// from the opcode.  If a custom code table were used that did not have
+// this property, then instructions_and_sizes_ might contain a
+// double-instruction opcode (say, COPY size 0 mode 0 + ADD size 0)
+// followed by the size of the COPY, then by the size of the ADD.
+// If using the SDCH interleaved format, the address of the COPY instruction
+// would follow its size, so the ordering would be
+// [Compound Opcode][Size of COPY][Address of COPY][Size of ADD]
+//
+void VCDiffCodeTableWriter::EncodeInstruction(VCDiffInstructionType inst,
+                                              size_t size,
+                                              unsigned char mode) {
+  if (!instruction_map_) {
+    LOG(DFATAL) << "EncodeInstruction() called without calling Init()"
+                << LOG_ENDL;
+    return;
+  }
+  if (last_opcode_index_ >= 0) {
+    const unsigned char last_opcode =
+        instructions_and_sizes_[last_opcode_index_];
+    // The encoding engine should not generate two ADD instructions in a row.
+    // This won't cause a failure, but it's inefficient encoding and probably
+    // represents a bug in the higher-level logic of the encoder.
+    if ((inst == VCD_ADD) &&
+        (code_table_data_->inst1[last_opcode] == VCD_ADD)) {
+      LOG(WARNING) << "EncodeInstruction() called for two ADD instructions"
+                      " in a row" << LOG_ENDL;
+    }
+    OpcodeOrNone compound_opcode = kNoOpcode;
+    if (size <= UCHAR_MAX) {
+      compound_opcode =
+          instruction_map_->LookupSecondOpcode(last_opcode,
+                                               inst,
+                                               static_cast<unsigned char>(size),
+                                               mode);
+      if (compound_opcode != kNoOpcode) {
+        instructions_and_sizes_[last_opcode_index_] =
+            static_cast<unsigned char>(compound_opcode);
+        last_opcode_index_ = -1;
+        return;
+      }
+    }
+    // Try finding a compound opcode with size 0.
+    compound_opcode = instruction_map_->LookupSecondOpcode(last_opcode,
+                                                           inst,
+                                                           0,
+                                                           mode);
+    if (compound_opcode != kNoOpcode) {
+      instructions_and_sizes_[last_opcode_index_] =
+          static_cast<unsigned char>(compound_opcode);
+      last_opcode_index_ = -1;
+      AppendSizeToString(size, &instructions_and_sizes_);
+      return;
+    }
+  }
+  OpcodeOrNone opcode = kNoOpcode;
+  if (size <= UCHAR_MAX) {
+    opcode =
+        instruction_map_->LookupFirstOpcode(inst,
+                                            static_cast<unsigned char>(size),
+                                            mode);
+    if (opcode != kNoOpcode) {
+      instructions_and_sizes_.push_back(static_cast<char>(opcode));
+      last_opcode_index_ = static_cast<int>(instructions_and_sizes_.size() - 1);
+      return;
+    }
+  }
+  // There should always be an opcode with size 0.
+  opcode = instruction_map_->LookupFirstOpcode(inst, 0, mode);
+  if (opcode == kNoOpcode) {
+    LOG(DFATAL) << "No matching opcode found for inst " << inst
+                << ", mode " << mode << ", size 0" << LOG_ENDL;
+    return;
+  }
+  instructions_and_sizes_.push_back(static_cast<char>(opcode));
+  last_opcode_index_ = static_cast<int>(instructions_and_sizes_.size() - 1);
+  AppendSizeToString(size, &instructions_and_sizes_);
+}
+
+void VCDiffCodeTableWriter::Add(const char* data, size_t size) {
+  EncodeInstruction(VCD_ADD, size);
+  data_for_add_and_run_->append(data, size);
+  target_length_ += size;
+}
+
+void VCDiffCodeTableWriter::Copy(int32_t offset, size_t size) {
+  if (!instruction_map_) {
+    LOG(DFATAL) << "VCDiffCodeTableWriter::Copy() called without calling Init()"
+                << LOG_ENDL;
+    return;
+  }
+  // If a single interleaved stream of encoded values is used
+  // instead of separate sections for instructions, addresses, and data,
+  // then the string instructions_and_sizes_ may be the same as
+  // addresses_for_copy_.  The address should therefore be encoded
+  // *after* the instruction and its size.
+  int32_t encoded_addr = 0;
+  const unsigned char mode = address_cache_.EncodeAddress(
+      offset,
+      static_cast<VCDAddress>(dictionary_size_ + target_length_),
+      &encoded_addr);
+  EncodeInstruction(VCD_COPY, size, mode);
+  if (address_cache_.WriteAddressAsVarintForMode(mode)) {
+    VarintBE<int32_t>::AppendToString(encoded_addr, addresses_for_copy_);
+  } else {
+    addresses_for_copy_->push_back(static_cast<unsigned char>(encoded_addr));
+  }
+  target_length_ += size;
+  if (size >= match_counts_.size()) {
+    match_counts_.resize(size * 2, 0);  // Be generous to avoid resizing again
+  }
+  ++match_counts_[size];
+}
+
+void VCDiffCodeTableWriter::Run(size_t size, unsigned char byte) {
+  EncodeInstruction(VCD_RUN, size);
+  data_for_add_and_run_->push_back(byte);
+  target_length_ += size;
+}
+
+size_t VCDiffCodeTableWriter::CalculateLengthOfSizeAsVarint(size_t size) {
+  return VarintBE<int32_t>::Length(static_cast<int32_t>(size));
+}
+
+void VCDiffCodeTableWriter::AppendSizeToString(size_t size, string* out) {
+  VarintBE<int32_t>::AppendToString(static_cast<int32_t>(size), out);
+}
+
+void VCDiffCodeTableWriter::AppendSizeToOutputString(
+    size_t size,
+    OutputStringInterface* out) {
+  VarintBE<int32_t>::AppendToOutputString(static_cast<int32_t>(size), out);
+}
+
+// This calculation must match the items added between "Start of Delta Encoding"
+// and "End of Delta Encoding" in Output(), below.
+size_t VCDiffCodeTableWriter::CalculateLengthOfTheDeltaEncoding() const {
+  size_t length_of_the_delta_encoding =
+    CalculateLengthOfSizeAsVarint(target_length_) +
+    1 +  // Delta_Indicator
+    CalculateLengthOfSizeAsVarint(separate_data_for_add_and_run_.size()) +
+    CalculateLengthOfSizeAsVarint(instructions_and_sizes_.size()) +
+    CalculateLengthOfSizeAsVarint(separate_addresses_for_copy_.size()) +
+    separate_data_for_add_and_run_.size() +
+    instructions_and_sizes_.size() +
+    separate_addresses_for_copy_.size();
+  if (add_checksum_) {
+    length_of_the_delta_encoding +=
+        VarintBE<int64_t>::Length(static_cast<int64_t>(checksum_));
+  }
+  return length_of_the_delta_encoding;
+}
+
+void VCDiffCodeTableWriter::Output(OutputStringInterface* out) {
+  if (instructions_and_sizes_.empty()) {
+    LOG(WARNING) << "Empty input; no delta window produced" << LOG_ENDL;
+  } else {
+    const size_t length_of_the_delta_encoding =
+        CalculateLengthOfTheDeltaEncoding();
+    const size_t delta_window_size =
+        length_of_the_delta_encoding +
+        1 +  // Win_Indicator
+        CalculateLengthOfSizeAsVarint(dictionary_size_) +
+        CalculateLengthOfSizeAsVarint(0) +
+        CalculateLengthOfSizeAsVarint(length_of_the_delta_encoding);
+    // append() will be called many times on the output string; make sure
+    // the output string is resized only once at most.
+    out->ReserveAdditionalBytes(delta_window_size);
+
+    // Add first element: Win_Indicator
+    if (add_checksum_) {
+      out->push_back(VCD_SOURCE | VCD_CHECKSUM);
+    } else {
+      out->push_back(VCD_SOURCE);
+    }
+    // Source segment size: dictionary size
+    AppendSizeToOutputString(dictionary_size_, out);
+    // Source segment position: 0 (start of dictionary)
+    AppendSizeToOutputString(0, out);
+
+    // [Here is where a secondary compressor would be used
+    //  if the encoder and decoder supported that feature.]
+
+    AppendSizeToOutputString(length_of_the_delta_encoding, out);
+    // Start of Delta Encoding
+    const size_t size_before_delta_encoding = out->size();
+    AppendSizeToOutputString(target_length_, out);
+    out->push_back(0x00);  // Delta_Indicator: no compression
+    AppendSizeToOutputString(separate_data_for_add_and_run_.size(), out);
+    AppendSizeToOutputString(instructions_and_sizes_.size(), out);
+    AppendSizeToOutputString(separate_addresses_for_copy_.size(), out);
+    if (add_checksum_) {
+      // The checksum is a 32-bit *unsigned* integer.  VarintBE requires a
+      // signed type, so use a 64-bit signed integer to store the checksum.
+      VarintBE<int64_t>::AppendToOutputString(static_cast<int64_t>(checksum_),
+                                              out);
+    }
+    out->append(separate_data_for_add_and_run_.data(),
+                separate_data_for_add_and_run_.size());
+    out->append(instructions_and_sizes_.data(),
+                instructions_and_sizes_.size());
+    out->append(separate_addresses_for_copy_.data(),
+                separate_addresses_for_copy_.size());
+    // End of Delta Encoding
+    const size_t size_after_delta_encoding = out->size();
+    if (length_of_the_delta_encoding !=
+        (size_after_delta_encoding - size_before_delta_encoding)) {
+      LOG(DFATAL) << "Internal error: calculated length of the delta encoding ("
+                  << length_of_the_delta_encoding
+                  << ") does not match actual length ("
+                  << (size_after_delta_encoding - size_before_delta_encoding)
+                  << LOG_ENDL;
+    }
+    separate_data_for_add_and_run_.clear();
+    instructions_and_sizes_.clear();
+    separate_addresses_for_copy_.clear();
+    if (target_length_ == 0) {
+      LOG(WARNING) << "Empty target window" << LOG_ENDL;
+    }
+  }
+
+  // Reset state for next window; assume we are using same code table
+  // and dictionary.  The caller will have to invoke Init() if a different
+  // dictionary is used.
+  //
+  // Notably, Init() calls address_cache_.Init().  This resets the address
+  // cache between delta windows, as required by RFC section 5.1.
+  if (!Init(dictionary_size_)) {
+    LOG(DFATAL) << "Internal error: calling Init() to reset "
+                   "VCDiffCodeTableWriter state failed" << LOG_ENDL;
+  }
+}
+
+};  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/encodetable.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/encodetable.h
new file mode 100644
index 0000000..57010cf
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/encodetable.h
@@ -0,0 +1,428 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// There are two different representations of a Code Table's contents:
+// VCDiffCodeTableData is the same as the format given in section 7
+// of the RFC, and is used for transmission and decoding.  However,
+// on the encoding side, it is useful to have a representation that
+// can map efficiently from delta instructions to opcodes:
+// VCDiffInstructionMap.  A VCDiffInstructionMap is constructed
+// using a VCDiffCodeTableData.  For a custom code table, it is recommended
+// that the VCDiffCodeTableData be defined as a static struct and that the
+// VCDiffInstructionMap be a static pointer that gets initialized only once.
+
+#ifndef OPEN_VCDIFF_ENCODETABLE_H_
+#define OPEN_VCDIFF_ENCODETABLE_H_
+
+#include <config.h>
+#include <stdint.h>             // int32_t
+#include <cstddef>              // size_t
+#include <string>
+#include <vector>
+#include "addrcache.h"
+#include "codetable.h"
+#include "checksum.h"
+#include "vcdiff_defs.h"
+
+namespace open_vcdiff {
+
+using std::string;
+
+class OutputStringInterface;
+struct VCDiffCodeTableData;
+
+// An alternate representation of the data in a VCDiffCodeTableData that
+// optimizes for fast encoding, that is, for taking a delta instruction
+// inst (also known as instruction type), size, and mode and arriving at
+// the corresponding opcode.
+//
+class VCDiffInstructionMap {
+ public:
+  // Create a VCDiffInstructionMap from the information in code_table_data.
+  // Does not save a pointer to code_table_data after using its contents
+  // to create the instruction->opcode mappings.  The caller *must* have
+  // verified that code_table_data->Validate() returned true before
+  // attempting to use this constructor.
+  // max_mode is the maximum value for the mode of a COPY instruction.
+  //
+  VCDiffInstructionMap(const VCDiffCodeTableData& code_table_data,
+                       unsigned char max_mode);
+
+  static VCDiffInstructionMap* GetDefaultInstructionMap();
+
+  // Finds an opcode that has the given inst, size, and mode for its first
+  // instruction  and NOOP for its second instruction (or vice versa.)
+  // Returns kNoOpcode if the code table does not have any matching
+  // opcode. Otherwise, returns an opcode value between 0 and 255.
+  //
+  // If this function returns kNoOpcode for size > 0, the caller will
+  // usually want to try again with size == 0 to find an opcode that
+  // doesn't have a fixed size value.
+  //
+  // If this function returns kNoOpcode for size == 0, it is an error condition,
+  // because any code table that passed the Validate() check should have a way
+  // of expressing all combinations of inst and mode with size=0.
+  //
+  OpcodeOrNone LookupFirstOpcode(unsigned char inst,
+                                 unsigned char size,
+                                 unsigned char mode) const {
+    return first_instruction_map_.Lookup(inst, size, mode);
+  }
+
+  // Given a first opcode (presumed to have been returned by a previous call to
+  // lookupFirstOpcode), finds an opcode that has the same first instruction as
+  // the first opcode, and has the given inst, size, and mode for its second
+  // instruction.
+  //
+  // If this function returns kNoOpcode for size > 0, the caller will
+  // usually want to try again with size == 0 to find an opcode that
+  // doesn't have a fixed size value.
+  //
+  OpcodeOrNone LookupSecondOpcode(unsigned char first_opcode,
+                                  unsigned char inst,
+                                  unsigned char size,
+                                  unsigned char mode) const {
+    return second_instruction_map_.Lookup(first_opcode, inst, size, mode);
+  }
+
+ private:
+  // Data structure used to implement LookupFirstOpcode efficiently.
+  //
+  class FirstInstructionMap {
+   public:
+    FirstInstructionMap(int num_insts_and_modes, int max_size_1);
+    ~FirstInstructionMap();
+
+    void Add(unsigned char inst,
+             unsigned char size,
+             unsigned char mode,
+             unsigned char opcode) {
+      OpcodeOrNone* opcode_slot = &first_opcodes_[inst + mode][size];
+      if (*opcode_slot == kNoOpcode) {
+        *opcode_slot = opcode;
+      }
+    }
+
+    // See comments for LookupFirstOpcode, above.
+    //
+    OpcodeOrNone Lookup(unsigned char inst,
+                        unsigned char size,
+                        unsigned char mode) const {
+      int inst_mode = (inst == VCD_COPY) ? (inst + mode) : inst;
+      if (size > max_size_1_) {
+        return kNoOpcode;
+      }
+      // Lookup specific-sized opcode
+      return first_opcodes_[inst_mode][size];
+    }
+
+   private:
+    // The number of possible combinations of inst (a VCDiffInstructionType) and
+    // mode.  Since the mode is only used for COPY instructions, this number
+    // is not (number of VCDiffInstructionType values) * (number of modes), but
+    // rather (number of VCDiffInstructionType values other than VCD_COPY)
+    // + (number of COPY modes).
+    //
+    // Compressing inst and mode into a single integer relies on
+    // VCD_COPY being the last instruction type.  The inst+mode values are:
+    // 0 (NOOP), 1 (ADD), 2 (RUN), 3 (COPY mode 0), 4 (COPY mode 1), ...
+    //
+    const int num_instruction_type_modes_;
+
+    // The maximum value of a size1 element in code_table_data
+    //
+    const int max_size_1_;
+
+    // There are two levels to first_opcodes_:
+    // 1) A dynamically-allocated pointer array of size
+    //    num_instruction_type_modes_ (one element for each combination of inst
+    //    and mode.)  Every element of this array is non-NULL and contains
+    //    a pointer to:
+    // 2) A dynamically-allocated array of OpcodeOrNone values, with one element
+    //    for each possible first instruction size (size1) in the code table.
+    //    (In the default code table, for example, the maximum size used is 18,
+    //    so these arrays would have 19 elements representing values 0
+    //    through 18.)
+    //
+    OpcodeOrNone** first_opcodes_;
+
+    // Making these private avoids implicit copy constructor
+    // and assignment operator
+    FirstInstructionMap(const FirstInstructionMap&);  // NOLINT
+    void operator=(const FirstInstructionMap&);
+  } first_instruction_map_;
+
+  // Data structure used to implement LookupSecondOpcode efficiently.
+  //
+  class SecondInstructionMap {
+   public:
+    SecondInstructionMap(int num_insts_and_modes, int max_size_2);
+    ~SecondInstructionMap();
+    void Add(unsigned char first_opcode,
+             unsigned char inst,
+             unsigned char size,
+             unsigned char mode,
+             unsigned char second_opcode);
+
+    // See comments for LookupSecondOpcode, above.
+    OpcodeOrNone Lookup(unsigned char first_opcode,
+                        unsigned char inst,
+                        unsigned char size,
+                        unsigned char mode) const;
+   private:
+    // See the member of the same name in FirstInstructionMap.
+    const int num_instruction_type_modes_;
+
+    // The maximum value of a size2 element in code_table_data
+    const int max_size_2_;
+
+    // There are three levels to second_opcodes_:
+    // 1) A statically-allocated pointer array with one element
+    //    for each possible opcode.  Each element can be NULL, or can point to:
+    // 2) A dynamically-allocated pointer array of size
+    //    num_instruction_type_modes_ (one element for each combination of inst
+    //    and mode.)  Each element can be NULL, or can point to:
+    // 3) A dynamically-allocated array with one element for each possible
+    //    second instruction size in the code table.  (In the default code
+    //    table, for example, the maximum size used is 6, so these arrays would
+    //    have 7 elements representing values 0 through 6.)
+    //
+    OpcodeOrNone** second_opcodes_[VCDiffCodeTableData::kCodeTableSize];
+
+    // Making these private avoids implicit copy constructor
+    // and assignment operator
+    SecondInstructionMap(const SecondInstructionMap&);  // NOLINT
+    void operator=(const SecondInstructionMap&);
+  } second_instruction_map_;
+
+  static VCDiffInstructionMap* default_instruction_map;
+
+  // Making these private avoids implicit copy constructor & assignment operator
+  VCDiffInstructionMap(const VCDiffInstructionMap&);  // NOLINT
+  void operator=(const VCDiffInstructionMap&);
+};
+
+// The method calls after construction *must* conform
+// to the following pattern:
+//    {{Add|Copy|Run}* [AddChecksum] Output}*
+//
+// When Output has been called in this sequence, a complete target window
+// (as defined in RFC 3284 section 4.3) will have been appended to
+// out (unless no calls to Add, Run, or Copy were made, in which
+// case Output will do nothing.)  The output will not be available for use
+// until after each call to Output().
+//
+// This class can also write a compressed
+// representation of a non-standard code table to an string so that it
+// can be sent with the data that was encoded using that code table.
+//
+// NOT threadsafe.
+//
+class VCDiffCodeTableWriter {
+ public:
+  // This constructor uses the default code table.
+  // If interleaved is true, the encoder writes each delta file window
+  // by interleaving instructions and sizes with their corresponding
+  // addresses and data, rather than placing these elements into three
+  // separate sections.  This facilitates providing partially
+  // decoded results when only a portion of a delta file window
+  // is received (e.g. when HTTP over TCP is used as the
+  // transmission protocol.)  The interleaved format is
+  // not consistent with the VCDIFF draft standard.
+  //
+  explicit VCDiffCodeTableWriter(bool interleaved);
+
+  // Uses a non-standard code table and non-standard cache sizes.  The caller
+  // must guarantee that code_table_data remains allocated for the lifetime of
+  // the VCDiffCodeTableWriter object.  Note that this is different from how
+  // VCDiffCodeTableReader::UseCodeTable works.  It is assumed that a given
+  // encoder will use either the default code table or a statically-defined
+  // non-standard code table, whereas the decoder must have the ability to read
+  // an arbitrary non-standard code table from a delta file and discard it once
+  // the file has been decoded.
+  //
+  VCDiffCodeTableWriter(bool interleaved,
+                        int near_cache_size,
+                        int same_cache_size,
+                        const VCDiffCodeTableData& code_table_data,
+                        unsigned char max_mode);
+
+  ~VCDiffCodeTableWriter();
+
+  // Initializes the constructed object for use.
+  // This method must be called after a VCDiffCodeTableWriter is constructed
+  // and before any of its other methods can be called.  It will return
+  // false if there was an error initializing the object, or true if it
+  // was successful.  After the object has been initialized and used,
+  // Init() can be called again to restore the initial state of the object.
+  //
+  bool Init(size_t dictionary_size);
+
+  size_t target_length() const { return target_length_; }
+
+  // Encode an ADD opcode with the "size" bytes starting at data
+  //
+  void Add(const char* data, size_t size);
+
+  // Encode a COPY opcode with args "offset" (into dictionary) and "size" bytes.
+  //
+  void Copy(int32_t offset, size_t size);
+
+  // Encode a RUN opcode for "size" copies of the value "byte".
+  //
+  void Run(size_t size, unsigned char byte);
+
+  void AddChecksum(VCDChecksum checksum) {
+    add_checksum_ = true;
+    checksum_ = checksum;
+  }
+
+  // Finishes encoding and appends the encoded delta window to the output
+  // string.  The output string is not null-terminated and may contain embedded
+  // '\0' characters.
+  void Output(OutputStringInterface* out);
+
+  const std::vector<int>& match_counts() const { return match_counts_; }
+
+ private:
+  // This is an estimate of the longest match size the encoder expects to find.
+  // It is used to determine the initial size of the vector match_counts_.
+  // If it is too large, then some space will be wasted on vector elements
+  // that are not used.  If it is too small, then some time will be wasted
+  // expanding match_counts_ to accommodate larger match sizes.
+  static const size_t kMaxMatchSize = 2000;
+
+  // The maximum value for the mode of a COPY instruction.
+  const unsigned char max_mode_;
+
+  // If interleaved is true, sets data_for_add_and_run_ and
+  // addresses_for_copy_ to point at instructions_and_sizes_,
+  // so that instructions, sizes, addresses and data will be
+  // combined into a single interleaved stream.
+  // If interleaved is false, sets data_for_add_and_run_ and
+  // addresses_for_copy_ to point at their corresponding
+  // separate_... strings, so that the three sections will
+  // be generated separately from one another.
+  //
+  void InitSectionPointers(bool interleaved);
+
+  // Determines the best opcode to encode an instruction, and appends
+  // or substitutes that opcode and its size into the
+  // instructions_and_sizes_ string.
+  //
+  void EncodeInstruction(VCDiffInstructionType inst,
+                         size_t size,
+                         unsigned char mode);
+
+  void EncodeInstruction(VCDiffInstructionType inst, size_t size) {
+    return EncodeInstruction(inst, size, 0);
+  }
+
+  // Calculates the number of bytes needed to store the given size value as a
+  // variable-length integer (VarintBE).
+  static size_t CalculateLengthOfSizeAsVarint(size_t size);
+
+  // Appends the size value to the string as a variable-length integer.
+  static void AppendSizeToString(size_t size, string* out);
+
+  // Appends the size value to the output string as a variable-length integer.
+  static void AppendSizeToOutputString(size_t size, OutputStringInterface* out);
+
+  // Calculates the "Length of the delta encoding" field for the delta window
+  // header, based on the sizes of the sections and of the other header
+  // elements.
+  size_t CalculateLengthOfTheDeltaEncoding() const;
+
+  // None of the following 'string' objects are null-terminated.
+
+  // A series of instruction opcodes, each of which may be followed
+  // by one or two Varint values representing the size parameters
+  // of the first and second instruction in the opcode.
+  string instructions_and_sizes_;
+
+  // A series of data arguments (byte values) used for ADD and RUN
+  // instructions.  Depending on whether interleaved output is used
+  // for streaming or not, the pointer may point to
+  // separate_data_for_add_and_run_ or to instructions_and_sizes_.
+  string *data_for_add_and_run_;
+  string separate_data_for_add_and_run_;
+
+  // A series of Varint addresses used for COPY instructions.
+  // For the SAME mode, a byte value is stored instead of a Varint.
+  // Depending on whether interleaved output is used
+  // for streaming or not, the pointer may point to
+  // separate_addresses_for_copy_ or to instructions_and_sizes_.
+  string *addresses_for_copy_;
+  string separate_addresses_for_copy_;
+
+  VCDiffAddressCache address_cache_;
+
+  size_t dictionary_size_;
+
+  // The number of bytes of target data that has been encoded so far.
+  // Each time Add(), Copy(), or Run() is called, this will be incremented.
+  // The target length is used to compute HERE mode addresses
+  // for COPY instructions, and is also written into the header
+  // of the delta window when Output() is called.
+  //
+  size_t target_length_;
+
+  const VCDiffCodeTableData* code_table_data_;
+
+  // The instruction map facilitates finding an opcode quickly given an
+  // instruction inst, size, and mode.  This is an alternate representation
+  // of the same information that is found in code_table_data_.
+  //
+  const VCDiffInstructionMap* instruction_map_;
+
+  // The zero-based index within instructions_and_sizes_ of the byte
+  // that contains the last single-instruction opcode generated by
+  // EncodeInstruction().  (See that function for exhaustive details.)
+  // It is necessary to use an index rather than a pointer for this value
+  // because instructions_and_sizes_ may be resized, which would invalidate
+  // any pointers into its data buffer.  The value -1 is reserved to mean that
+  // either no opcodes have been generated yet, or else the last opcode
+  // generated was a double-instruction opcode.
+  //
+  int last_opcode_index_;
+
+  // If true, an Adler32 checksum of the target window data will be written as
+  // a variable-length integer, just after the size of the addresses section.
+  //
+  bool add_checksum_;
+
+  // The checksum to be written to the current target window,
+  // if add_checksum_ is true.
+  // This will not be calculated based on the individual calls to Add(), Run(),
+  // and Copy(), which would be unnecessarily expensive.  Instead, the code
+  // that uses the VCDiffCodeTableWriter object is expected to calculate
+  // the checksum all at once and to call AddChecksum() with that value.
+  // Must be called sometime before calling Output(), though it can be called
+  // either before or after the calls to Add(), Run(), and Copy().
+  //
+  VCDChecksum checksum_;
+
+  // The value of match_counts_[n] is equal to the number of matches
+  // of length n (that is, COPY instructions of size n) found so far.
+  std::vector<int> match_counts_;
+
+  // Making these private avoids implicit copy constructor & assignment operator
+  VCDiffCodeTableWriter(const VCDiffCodeTableWriter&);  // NOLINT
+  void operator=(const VCDiffCodeTableWriter&);
+};
+
+};  // namespace open_vcdiff
+
+#endif  // OPEN_VCDIFF_ENCODETABLE_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/encodetable_test.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/encodetable_test.cc
new file mode 100644
index 0000000..7043152
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/encodetable_test.cc
@@ -0,0 +1,957 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Unit tests for the classes VCDiffCodeTableWriter and VCDiffInstructionMap,
+// found in encodetable.h.
+
+#include <config.h>
+#include "encodetable.h"
+#include <algorithm>
+#include <cstring>  // strlen
+#include <string>
+#include <vector>
+#include "addrcache.h"  // kDefaultNear...
+#include "checksum.h"
+#include "codetable.h"
+#include "google/output_string.h"
+#include "testing.h"
+#include "varint_bigendian.h"
+#include "vcdiff_defs.h"
+
+namespace open_vcdiff {
+namespace {
+
+using std::string;
+
+class EncodeTableTest : public testing::Test {
+ protected:
+  // Remove all of the functions below that are not useful for this
+  // test fixture.
+
+  EncodeTableTest()
+      : standard_writer(false),
+        interleaved_writer(true),
+        exercise_writer(true,
+                        VCDiffAddressCache::kDefaultNearCacheSize,
+                        VCDiffAddressCache::kDefaultSameCacheSize,
+                        *g_exercise_code_table_, kLastExerciseMode),
+        output_string(&out),
+        out_index(0) { }
+
+  virtual ~EncodeTableTest() { }
+
+  static void AddExerciseOpcode(unsigned char inst1,
+                                unsigned char mode1,
+                                unsigned char size1,
+                                unsigned char inst2,
+                                unsigned char mode2,
+                                unsigned char size2,
+                                int opcode) {
+    g_exercise_code_table_->inst1[opcode] = inst1;
+    g_exercise_code_table_->mode1[opcode] = mode1;
+    g_exercise_code_table_->size1[opcode] = (inst1 == VCD_NOOP) ? 0 : size1;
+    g_exercise_code_table_->inst2[opcode] = inst2;
+    g_exercise_code_table_->mode2[opcode] = mode2;
+    g_exercise_code_table_->size2[opcode] = (inst2 == VCD_NOOP) ? 0 : size2;
+  }
+
+  static void SetUpTestCase() {
+    g_exercise_code_table_ = new VCDiffCodeTableData;
+    int opcode = 0;
+    for (unsigned char inst_mode1 = 0;
+         inst_mode1 <= VCD_LAST_INSTRUCTION_TYPE + kLastExerciseMode;
+         ++inst_mode1) {
+      unsigned char inst1 = inst_mode1;
+      unsigned char mode1 = 0;
+      if (inst_mode1 > VCD_COPY) {
+        inst1 = VCD_COPY;
+        mode1 = inst_mode1 - VCD_COPY;
+      }
+      for (unsigned char inst_mode2 = 0;
+           inst_mode2 <= VCD_LAST_INSTRUCTION_TYPE + kLastExerciseMode;
+           ++inst_mode2) {
+        unsigned char inst2 = inst_mode2;
+        unsigned char mode2 = 0;
+        if (inst_mode2 > VCD_COPY) {
+          inst2 = VCD_COPY;
+          mode2 = inst_mode2 - VCD_COPY;
+        }
+        AddExerciseOpcode(inst1, mode1, 0, inst2, mode2, 0, opcode++);
+        AddExerciseOpcode(inst1, mode1, 0, inst2, mode2, 255, opcode++);
+        AddExerciseOpcode(inst1, mode1, 255, inst2, mode2, 0, opcode++);
+        AddExerciseOpcode(inst1, mode1, 255, inst2, mode2, 255, opcode++);
+      }
+    }
+    // This is a CHECK rather than an EXPECT because it validates only
+    // the logic of the test, not of the code being tested.
+    CHECK_EQ(VCDiffCodeTableData::kCodeTableSize, opcode);
+
+    EXPECT_TRUE(VCDiffCodeTableData::kDefaultCodeTableData.Validate());
+    EXPECT_TRUE(g_exercise_code_table_->Validate(kLastExerciseMode));
+    default_map = VCDiffInstructionMap::GetDefaultInstructionMap();
+    exercise_map = new VCDiffInstructionMap(*g_exercise_code_table_,
+                                            kLastExerciseMode);
+  }
+
+  static void TearDownTestCase() {
+    delete exercise_map;
+    delete g_exercise_code_table_;
+  }
+
+  void VerifyExerciseFirstInstruction(unsigned char expected_opcode,
+                                      unsigned char inst,
+                                      unsigned char size,
+                                      unsigned char mode) {
+    int found_opcode = exercise_map->LookupFirstOpcode(inst, size, mode);
+    if (g_exercise_code_table_->inst1[found_opcode] == VCD_NOOP) {
+      // The opcode is backwards: (VCD_NOOP, [instruction])
+      EXPECT_GE(expected_opcode, found_opcode);
+      EXPECT_EQ(inst, g_exercise_code_table_->inst2[found_opcode]);
+      EXPECT_EQ(size, g_exercise_code_table_->size2[found_opcode]);
+      EXPECT_EQ(mode, g_exercise_code_table_->mode2[found_opcode]);
+      EXPECT_EQ(VCD_NOOP, g_exercise_code_table_->inst1[found_opcode]);
+      EXPECT_EQ(0, g_exercise_code_table_->size1[found_opcode]);
+      EXPECT_EQ(0, g_exercise_code_table_->mode1[found_opcode]);
+    } else {
+      EXPECT_EQ(expected_opcode, found_opcode);
+      EXPECT_EQ(inst, g_exercise_code_table_->inst1[found_opcode]);
+      EXPECT_EQ(size, g_exercise_code_table_->size1[found_opcode]);
+      EXPECT_EQ(mode, g_exercise_code_table_->mode1[found_opcode]);
+      EXPECT_EQ(VCD_NOOP, g_exercise_code_table_->inst2[found_opcode]);
+      EXPECT_EQ(0, g_exercise_code_table_->size2[found_opcode]);
+      EXPECT_EQ(0, g_exercise_code_table_->mode2[found_opcode]);
+    }
+  }
+
+  void VerifyExerciseSecondInstruction(unsigned char expected_opcode,
+                                       unsigned char inst1,
+                                       unsigned char size1,
+                                       unsigned char mode1,
+                                       unsigned char inst2,
+                                       unsigned char size2,
+                                       unsigned char mode2) {
+    int first_opcode = exercise_map->LookupFirstOpcode(inst1, size1, mode1);
+    EXPECT_NE(kNoOpcode, first_opcode);
+    EXPECT_EQ(expected_opcode,
+              exercise_map->LookupSecondOpcode(first_opcode,
+                                               inst2,
+                                               size2,
+                                               mode2));
+  }
+
+  void ExpectByte(unsigned char b) {
+    EXPECT_EQ(b, static_cast<unsigned char>(out[out_index]));
+    ++out_index;
+  }
+
+  void ExpectString(const char* s) {
+    const size_t size = strlen(s);  // don't include terminating NULL char
+    EXPECT_EQ(string(s, size),
+              string(out.data() + out_index, size));
+    out_index += size;
+  }
+
+  void ExpectNoMoreBytes() {
+    EXPECT_EQ(out_index, out.size());
+  }
+
+  static bool AnyMatch(int match_count) { return match_count != 0; }
+
+  static void ExpectNoMatchesForWriter(const VCDiffCodeTableWriter& writer) {
+    const std::vector<int>& match_counts = writer.match_counts();
+    EXPECT_TRUE(find_if(match_counts.begin(), match_counts.end(), AnyMatch)
+                    == match_counts.end());
+  }
+
+  void ExpectNoMatches() const {
+    ExpectNoMatchesForWriter(standard_writer);
+    ExpectNoMatchesForWriter(interleaved_writer);
+    ExpectNoMatchesForWriter(exercise_writer);
+  }
+
+  // This value is designed so that the total number of inst values and modes
+  // will equal 8 (VCD_NOOP, VCD_ADD, VCD_RUN, VCD_COPY modes 0 - 4).
+  // Eight combinations of inst and mode, times two possible size values,
+  // squared (because there are two instructions per opcode), makes
+  // exactly 256 possible instruction combinations, which fits kCodeTableSize
+  // (the number of opcodes in the table.)
+  static const int kLastExerciseMode = 4;
+
+  // A code table that exercises as many combinations as possible:
+  // 2 instructions, each is a NOOP, ADD, RUN, or one of 5 copy modes
+  // (== 8 total combinations of inst and mode), and each has
+  // size == 0 or 255 (2 possibilities.)
+  static VCDiffCodeTableData* g_exercise_code_table_;
+
+  // The instruction map corresponding to kDefaultCodeTableData.
+  static const VCDiffInstructionMap* default_map;
+
+  // The instruction map corresponding to g_exercise_code_table_.
+  static const VCDiffInstructionMap* exercise_map;
+
+  // The code table writer for standard encoding, default code table.
+  VCDiffCodeTableWriter standard_writer;
+
+  // The code table writer for interleaved encoding, default code table.
+  VCDiffCodeTableWriter interleaved_writer;
+
+  // The code table writer corresponding to g_exercise_code_table_
+  // (interleaved encoding).
+  VCDiffCodeTableWriter exercise_writer;
+
+  // Destination for VCDiffCodeTableWriter::Output()
+  string out;
+  OutputString<string> output_string;
+  size_t out_index;
+};
+
+VCDiffCodeTableData* EncodeTableTest::g_exercise_code_table_;
+const VCDiffInstructionMap* EncodeTableTest::default_map;
+const VCDiffInstructionMap* EncodeTableTest::exercise_map;
+
+#ifdef GTEST_HAS_DEATH_TEST
+typedef EncodeTableTest EncodeTableDeathTest;
+#endif  // GTEST_HAS_DEATH_TEST
+
+TEST_F(EncodeTableTest, DefaultMapLookupFirstNoop) {
+  EXPECT_EQ(kNoOpcode, default_map->LookupFirstOpcode(VCD_NOOP, 0, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupFirstOpcode(VCD_NOOP, 0, 255));
+  EXPECT_EQ(kNoOpcode, default_map->LookupFirstOpcode(VCD_NOOP, 255, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupFirstOpcode(VCD_NOOP, 255, 255));
+}
+
+TEST_F(EncodeTableTest, DefaultMapLookupFirstAdd) {
+  EXPECT_EQ(2, default_map->LookupFirstOpcode(VCD_ADD, 1, 0));
+  EXPECT_EQ(3, default_map->LookupFirstOpcode(VCD_ADD, 2, 0));
+  EXPECT_EQ(4, default_map->LookupFirstOpcode(VCD_ADD, 3, 0));
+  EXPECT_EQ(5, default_map->LookupFirstOpcode(VCD_ADD, 4, 0));
+  EXPECT_EQ(6, default_map->LookupFirstOpcode(VCD_ADD, 5, 0));
+  EXPECT_EQ(7, default_map->LookupFirstOpcode(VCD_ADD, 6, 0));
+  EXPECT_EQ(8, default_map->LookupFirstOpcode(VCD_ADD, 7, 0));
+  EXPECT_EQ(9, default_map->LookupFirstOpcode(VCD_ADD, 8, 0));
+  EXPECT_EQ(10, default_map->LookupFirstOpcode(VCD_ADD, 9, 0));
+  EXPECT_EQ(11, default_map->LookupFirstOpcode(VCD_ADD, 10, 0));
+  EXPECT_EQ(12, default_map->LookupFirstOpcode(VCD_ADD, 11, 0));
+  EXPECT_EQ(13, default_map->LookupFirstOpcode(VCD_ADD, 12, 0));
+  EXPECT_EQ(14, default_map->LookupFirstOpcode(VCD_ADD, 13, 0));
+  EXPECT_EQ(15, default_map->LookupFirstOpcode(VCD_ADD, 14, 0));
+  EXPECT_EQ(16, default_map->LookupFirstOpcode(VCD_ADD, 15, 0));
+  EXPECT_EQ(17, default_map->LookupFirstOpcode(VCD_ADD, 16, 0));
+  EXPECT_EQ(18, default_map->LookupFirstOpcode(VCD_ADD, 17, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupFirstOpcode(VCD_ADD, 100, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupFirstOpcode(VCD_ADD, 255, 0));
+  EXPECT_EQ(1, default_map->LookupFirstOpcode(VCD_ADD, 0, 0));
+  // Value of "mode" should not matter
+  EXPECT_EQ(2, default_map->LookupFirstOpcode(VCD_ADD, 1, 2));
+  EXPECT_EQ(2, default_map->LookupFirstOpcode(VCD_ADD, 1, 255));
+}
+
+TEST_F(EncodeTableTest, DefaultMapLookupFirstRun) {
+  EXPECT_EQ(0, default_map->LookupFirstOpcode(VCD_RUN, 0, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupFirstOpcode(VCD_RUN, 1, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupFirstOpcode(VCD_RUN, 255, 0));
+  // Value of "mode" should not matter
+  EXPECT_EQ(0, default_map->LookupFirstOpcode(VCD_RUN, 0, 2));
+}
+
+TEST_F(EncodeTableTest, DefaultMapLookupFirstCopy) {
+  EXPECT_EQ(19, default_map->LookupFirstOpcode(VCD_COPY, 0, 0));
+  EXPECT_EQ(20, default_map->LookupFirstOpcode(VCD_COPY, 4, 0));
+  EXPECT_EQ(21, default_map->LookupFirstOpcode(VCD_COPY, 5, 0));
+  EXPECT_EQ(22, default_map->LookupFirstOpcode(VCD_COPY, 6, 0));
+  EXPECT_EQ(23, default_map->LookupFirstOpcode(VCD_COPY, 7, 0));
+  EXPECT_EQ(24, default_map->LookupFirstOpcode(VCD_COPY, 8, 0));
+  EXPECT_EQ(25, default_map->LookupFirstOpcode(VCD_COPY, 9, 0));
+  EXPECT_EQ(26, default_map->LookupFirstOpcode(VCD_COPY, 10, 0));
+  EXPECT_EQ(27, default_map->LookupFirstOpcode(VCD_COPY, 11, 0));
+  EXPECT_EQ(28, default_map->LookupFirstOpcode(VCD_COPY, 12, 0));
+  EXPECT_EQ(29, default_map->LookupFirstOpcode(VCD_COPY, 13, 0));
+  EXPECT_EQ(30, default_map->LookupFirstOpcode(VCD_COPY, 14, 0));
+  EXPECT_EQ(31, default_map->LookupFirstOpcode(VCD_COPY, 15, 0));
+  EXPECT_EQ(32, default_map->LookupFirstOpcode(VCD_COPY, 16, 0));
+  EXPECT_EQ(33, default_map->LookupFirstOpcode(VCD_COPY, 17, 0));
+  EXPECT_EQ(34, default_map->LookupFirstOpcode(VCD_COPY, 18, 0));
+  EXPECT_EQ(35, default_map->LookupFirstOpcode(VCD_COPY, 0, 1));
+  EXPECT_EQ(36, default_map->LookupFirstOpcode(VCD_COPY, 4, 1));
+  EXPECT_EQ(37, default_map->LookupFirstOpcode(VCD_COPY, 5, 1));
+  EXPECT_EQ(38, default_map->LookupFirstOpcode(VCD_COPY, 6, 1));
+  EXPECT_EQ(39, default_map->LookupFirstOpcode(VCD_COPY, 7, 1));
+  EXPECT_EQ(40, default_map->LookupFirstOpcode(VCD_COPY, 8, 1));
+  EXPECT_EQ(41, default_map->LookupFirstOpcode(VCD_COPY, 9, 1));
+  EXPECT_EQ(42, default_map->LookupFirstOpcode(VCD_COPY, 10, 1));
+  EXPECT_EQ(43, default_map->LookupFirstOpcode(VCD_COPY, 11, 1));
+  EXPECT_EQ(44, default_map->LookupFirstOpcode(VCD_COPY, 12, 1));
+  EXPECT_EQ(45, default_map->LookupFirstOpcode(VCD_COPY, 13, 1));
+  EXPECT_EQ(46, default_map->LookupFirstOpcode(VCD_COPY, 14, 1));
+  EXPECT_EQ(47, default_map->LookupFirstOpcode(VCD_COPY, 15, 1));
+  EXPECT_EQ(48, default_map->LookupFirstOpcode(VCD_COPY, 16, 1));
+  EXPECT_EQ(49, default_map->LookupFirstOpcode(VCD_COPY, 17, 1));
+  EXPECT_EQ(50, default_map->LookupFirstOpcode(VCD_COPY, 18, 1));
+  EXPECT_EQ(51, default_map->LookupFirstOpcode(VCD_COPY, 0, 2));
+  EXPECT_EQ(52, default_map->LookupFirstOpcode(VCD_COPY, 4, 2));
+  EXPECT_EQ(53, default_map->LookupFirstOpcode(VCD_COPY, 5, 2));
+  EXPECT_EQ(54, default_map->LookupFirstOpcode(VCD_COPY, 6, 2));
+  EXPECT_EQ(55, default_map->LookupFirstOpcode(VCD_COPY, 7, 2));
+  EXPECT_EQ(56, default_map->LookupFirstOpcode(VCD_COPY, 8, 2));
+  EXPECT_EQ(57, default_map->LookupFirstOpcode(VCD_COPY, 9, 2));
+  EXPECT_EQ(58, default_map->LookupFirstOpcode(VCD_COPY, 10, 2));
+  EXPECT_EQ(59, default_map->LookupFirstOpcode(VCD_COPY, 11, 2));
+  EXPECT_EQ(60, default_map->LookupFirstOpcode(VCD_COPY, 12, 2));
+  EXPECT_EQ(61, default_map->LookupFirstOpcode(VCD_COPY, 13, 2));
+  EXPECT_EQ(62, default_map->LookupFirstOpcode(VCD_COPY, 14, 2));
+  EXPECT_EQ(63, default_map->LookupFirstOpcode(VCD_COPY, 15, 2));
+  EXPECT_EQ(64, default_map->LookupFirstOpcode(VCD_COPY, 16, 2));
+  EXPECT_EQ(65, default_map->LookupFirstOpcode(VCD_COPY, 17, 2));
+  EXPECT_EQ(66, default_map->LookupFirstOpcode(VCD_COPY, 18, 2));
+  EXPECT_EQ(67, default_map->LookupFirstOpcode(VCD_COPY, 0, 3));
+  EXPECT_EQ(68, default_map->LookupFirstOpcode(VCD_COPY, 4, 3));
+  EXPECT_EQ(69, default_map->LookupFirstOpcode(VCD_COPY, 5, 3));
+  EXPECT_EQ(70, default_map->LookupFirstOpcode(VCD_COPY, 6, 3));
+  EXPECT_EQ(71, default_map->LookupFirstOpcode(VCD_COPY, 7, 3));
+  EXPECT_EQ(72, default_map->LookupFirstOpcode(VCD_COPY, 8, 3));
+  EXPECT_EQ(73, default_map->LookupFirstOpcode(VCD_COPY, 9, 3));
+  EXPECT_EQ(74, default_map->LookupFirstOpcode(VCD_COPY, 10, 3));
+  EXPECT_EQ(75, default_map->LookupFirstOpcode(VCD_COPY, 11, 3));
+  EXPECT_EQ(76, default_map->LookupFirstOpcode(VCD_COPY, 12, 3));
+  EXPECT_EQ(77, default_map->LookupFirstOpcode(VCD_COPY, 13, 3));
+  EXPECT_EQ(78, default_map->LookupFirstOpcode(VCD_COPY, 14, 3));
+  EXPECT_EQ(79, default_map->LookupFirstOpcode(VCD_COPY, 15, 3));
+  EXPECT_EQ(80, default_map->LookupFirstOpcode(VCD_COPY, 16, 3));
+  EXPECT_EQ(81, default_map->LookupFirstOpcode(VCD_COPY, 17, 3));
+  EXPECT_EQ(82, default_map->LookupFirstOpcode(VCD_COPY, 18, 3));
+  EXPECT_EQ(83, default_map->LookupFirstOpcode(VCD_COPY, 0, 4));
+  EXPECT_EQ(84, default_map->LookupFirstOpcode(VCD_COPY, 4, 4));
+  EXPECT_EQ(85, default_map->LookupFirstOpcode(VCD_COPY, 5, 4));
+  EXPECT_EQ(86, default_map->LookupFirstOpcode(VCD_COPY, 6, 4));
+  EXPECT_EQ(87, default_map->LookupFirstOpcode(VCD_COPY, 7, 4));
+  EXPECT_EQ(88, default_map->LookupFirstOpcode(VCD_COPY, 8, 4));
+  EXPECT_EQ(89, default_map->LookupFirstOpcode(VCD_COPY, 9, 4));
+  EXPECT_EQ(90, default_map->LookupFirstOpcode(VCD_COPY, 10, 4));
+  EXPECT_EQ(91, default_map->LookupFirstOpcode(VCD_COPY, 11, 4));
+  EXPECT_EQ(92, default_map->LookupFirstOpcode(VCD_COPY, 12, 4));
+  EXPECT_EQ(93, default_map->LookupFirstOpcode(VCD_COPY, 13, 4));
+  EXPECT_EQ(94, default_map->LookupFirstOpcode(VCD_COPY, 14, 4));
+  EXPECT_EQ(95, default_map->LookupFirstOpcode(VCD_COPY, 15, 4));
+  EXPECT_EQ(96, default_map->LookupFirstOpcode(VCD_COPY, 16, 4));
+  EXPECT_EQ(97, default_map->LookupFirstOpcode(VCD_COPY, 17, 4));
+  EXPECT_EQ(98, default_map->LookupFirstOpcode(VCD_COPY, 18, 4));
+  EXPECT_EQ(99, default_map->LookupFirstOpcode(VCD_COPY, 0, 5));
+  EXPECT_EQ(100, default_map->LookupFirstOpcode(VCD_COPY, 4, 5));
+  EXPECT_EQ(101, default_map->LookupFirstOpcode(VCD_COPY, 5, 5));
+  EXPECT_EQ(102, default_map->LookupFirstOpcode(VCD_COPY, 6, 5));
+  EXPECT_EQ(103, default_map->LookupFirstOpcode(VCD_COPY, 7, 5));
+  EXPECT_EQ(104, default_map->LookupFirstOpcode(VCD_COPY, 8, 5));
+  EXPECT_EQ(105, default_map->LookupFirstOpcode(VCD_COPY, 9, 5));
+  EXPECT_EQ(106, default_map->LookupFirstOpcode(VCD_COPY, 10, 5));
+  EXPECT_EQ(107, default_map->LookupFirstOpcode(VCD_COPY, 11, 5));
+  EXPECT_EQ(108, default_map->LookupFirstOpcode(VCD_COPY, 12, 5));
+  EXPECT_EQ(109, default_map->LookupFirstOpcode(VCD_COPY, 13, 5));
+  EXPECT_EQ(110, default_map->LookupFirstOpcode(VCD_COPY, 14, 5));
+  EXPECT_EQ(111, default_map->LookupFirstOpcode(VCD_COPY, 15, 5));
+  EXPECT_EQ(112, default_map->LookupFirstOpcode(VCD_COPY, 16, 5));
+  EXPECT_EQ(113, default_map->LookupFirstOpcode(VCD_COPY, 17, 5));
+  EXPECT_EQ(114, default_map->LookupFirstOpcode(VCD_COPY, 18, 5));
+  EXPECT_EQ(115, default_map->LookupFirstOpcode(VCD_COPY, 0, 6));
+  EXPECT_EQ(116, default_map->LookupFirstOpcode(VCD_COPY, 4, 6));
+  EXPECT_EQ(117, default_map->LookupFirstOpcode(VCD_COPY, 5, 6));
+  EXPECT_EQ(118, default_map->LookupFirstOpcode(VCD_COPY, 6, 6));
+  EXPECT_EQ(119, default_map->LookupFirstOpcode(VCD_COPY, 7, 6));
+  EXPECT_EQ(120, default_map->LookupFirstOpcode(VCD_COPY, 8, 6));
+  EXPECT_EQ(121, default_map->LookupFirstOpcode(VCD_COPY, 9, 6));
+  EXPECT_EQ(122, default_map->LookupFirstOpcode(VCD_COPY, 10, 6));
+  EXPECT_EQ(123, default_map->LookupFirstOpcode(VCD_COPY, 11, 6));
+  EXPECT_EQ(124, default_map->LookupFirstOpcode(VCD_COPY, 12, 6));
+  EXPECT_EQ(125, default_map->LookupFirstOpcode(VCD_COPY, 13, 6));
+  EXPECT_EQ(126, default_map->LookupFirstOpcode(VCD_COPY, 14, 6));
+  EXPECT_EQ(127, default_map->LookupFirstOpcode(VCD_COPY, 15, 6));
+  EXPECT_EQ(128, default_map->LookupFirstOpcode(VCD_COPY, 16, 6));
+  EXPECT_EQ(129, default_map->LookupFirstOpcode(VCD_COPY, 17, 6));
+  EXPECT_EQ(130, default_map->LookupFirstOpcode(VCD_COPY, 18, 6));
+  EXPECT_EQ(131, default_map->LookupFirstOpcode(VCD_COPY, 0, 7));
+  EXPECT_EQ(132, default_map->LookupFirstOpcode(VCD_COPY, 4, 7));
+  EXPECT_EQ(133, default_map->LookupFirstOpcode(VCD_COPY, 5, 7));
+  EXPECT_EQ(134, default_map->LookupFirstOpcode(VCD_COPY, 6, 7));
+  EXPECT_EQ(135, default_map->LookupFirstOpcode(VCD_COPY, 7, 7));
+  EXPECT_EQ(136, default_map->LookupFirstOpcode(VCD_COPY, 8, 7));
+  EXPECT_EQ(137, default_map->LookupFirstOpcode(VCD_COPY, 9, 7));
+  EXPECT_EQ(138, default_map->LookupFirstOpcode(VCD_COPY, 10, 7));
+  EXPECT_EQ(139, default_map->LookupFirstOpcode(VCD_COPY, 11, 7));
+  EXPECT_EQ(140, default_map->LookupFirstOpcode(VCD_COPY, 12, 7));
+  EXPECT_EQ(141, default_map->LookupFirstOpcode(VCD_COPY, 13, 7));
+  EXPECT_EQ(142, default_map->LookupFirstOpcode(VCD_COPY, 14, 7));
+  EXPECT_EQ(143, default_map->LookupFirstOpcode(VCD_COPY, 15, 7));
+  EXPECT_EQ(144, default_map->LookupFirstOpcode(VCD_COPY, 16, 7));
+  EXPECT_EQ(145, default_map->LookupFirstOpcode(VCD_COPY, 17, 7));
+  EXPECT_EQ(146, default_map->LookupFirstOpcode(VCD_COPY, 18, 7));
+  EXPECT_EQ(147, default_map->LookupFirstOpcode(VCD_COPY, 0, 8));
+  EXPECT_EQ(148, default_map->LookupFirstOpcode(VCD_COPY, 4, 8));
+  EXPECT_EQ(149, default_map->LookupFirstOpcode(VCD_COPY, 5, 8));
+  EXPECT_EQ(150, default_map->LookupFirstOpcode(VCD_COPY, 6, 8));
+  EXPECT_EQ(151, default_map->LookupFirstOpcode(VCD_COPY, 7, 8));
+  EXPECT_EQ(152, default_map->LookupFirstOpcode(VCD_COPY, 8, 8));
+  EXPECT_EQ(153, default_map->LookupFirstOpcode(VCD_COPY, 9, 8));
+  EXPECT_EQ(154, default_map->LookupFirstOpcode(VCD_COPY, 10, 8));
+  EXPECT_EQ(155, default_map->LookupFirstOpcode(VCD_COPY, 11, 8));
+  EXPECT_EQ(156, default_map->LookupFirstOpcode(VCD_COPY, 12, 8));
+  EXPECT_EQ(157, default_map->LookupFirstOpcode(VCD_COPY, 13, 8));
+  EXPECT_EQ(158, default_map->LookupFirstOpcode(VCD_COPY, 14, 8));
+  EXPECT_EQ(159, default_map->LookupFirstOpcode(VCD_COPY, 15, 8));
+  EXPECT_EQ(160, default_map->LookupFirstOpcode(VCD_COPY, 16, 8));
+  EXPECT_EQ(161, default_map->LookupFirstOpcode(VCD_COPY, 17, 8));
+  EXPECT_EQ(162, default_map->LookupFirstOpcode(VCD_COPY, 18, 8));
+  EXPECT_EQ(kNoOpcode, default_map->LookupFirstOpcode(VCD_COPY, 3, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupFirstOpcode(VCD_COPY, 3, 3));
+  EXPECT_EQ(kNoOpcode, default_map->LookupFirstOpcode(VCD_COPY, 255, 0));
+}
+
+TEST_F(EncodeTableTest, DefaultMapLookupSecondNoop) {
+  // The second opcode table does not store entries for NOOP instructions.
+  // Just make sure that a NOOP does not crash the lookup code.
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(20, VCD_NOOP, 0, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(20, VCD_NOOP, 0, 255));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(20, VCD_NOOP, 255, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(20, VCD_NOOP, 255, 255));
+}
+
+TEST_F(EncodeTableTest, DefaultMapLookupSecondAdd) {
+  EXPECT_EQ(247, default_map->LookupSecondOpcode(20, VCD_ADD, 1, 0));
+  EXPECT_EQ(248, default_map->LookupSecondOpcode(36, VCD_ADD, 1, 0));
+  EXPECT_EQ(249, default_map->LookupSecondOpcode(52, VCD_ADD, 1, 0));
+  EXPECT_EQ(250, default_map->LookupSecondOpcode(68, VCD_ADD, 1, 0));
+  EXPECT_EQ(251, default_map->LookupSecondOpcode(84, VCD_ADD, 1, 0));
+  EXPECT_EQ(252, default_map->LookupSecondOpcode(100, VCD_ADD, 1, 0));
+  EXPECT_EQ(253, default_map->LookupSecondOpcode(116, VCD_ADD, 1, 0));
+  EXPECT_EQ(254, default_map->LookupSecondOpcode(132, VCD_ADD, 1, 0));
+  EXPECT_EQ(255, default_map->LookupSecondOpcode(148, VCD_ADD, 1, 0));
+  // Value of "mode" should not matter
+  EXPECT_EQ(247, default_map->LookupSecondOpcode(20, VCD_ADD, 1, 2));
+  EXPECT_EQ(247, default_map->LookupSecondOpcode(20, VCD_ADD, 1, 255));
+  // Only valid 2nd ADD opcode has size 1
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(20, VCD_ADD, 0, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(20, VCD_ADD, 0, 255));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(20, VCD_ADD, 255, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(0, VCD_ADD, 1, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(1, VCD_ADD, 1, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(247, VCD_ADD, 1, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(255, VCD_ADD, 1, 0));
+}
+
+TEST_F(EncodeTableTest, DefaultMapLookupSecondRun) {
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(0, VCD_RUN, 0, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(20, VCD_RUN, 0, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(20, VCD_RUN, 0, 255));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(20, VCD_RUN, 255, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(20, VCD_RUN, 255, 255));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(255, VCD_RUN, 0, 0));
+}
+
+TEST_F(EncodeTableTest, DefaultMapLookupSecondCopy) {
+  EXPECT_EQ(163, default_map->LookupSecondOpcode(2, VCD_COPY, 4, 0));
+  EXPECT_EQ(164, default_map->LookupSecondOpcode(2, VCD_COPY, 5, 0));
+  EXPECT_EQ(165, default_map->LookupSecondOpcode(2, VCD_COPY, 6, 0));
+  EXPECT_EQ(166, default_map->LookupSecondOpcode(3, VCD_COPY, 4, 0));
+  EXPECT_EQ(167, default_map->LookupSecondOpcode(3, VCD_COPY, 5, 0));
+  EXPECT_EQ(168, default_map->LookupSecondOpcode(3, VCD_COPY, 6, 0));
+  EXPECT_EQ(169, default_map->LookupSecondOpcode(4, VCD_COPY, 4, 0));
+  EXPECT_EQ(170, default_map->LookupSecondOpcode(4, VCD_COPY, 5, 0));
+  EXPECT_EQ(171, default_map->LookupSecondOpcode(4, VCD_COPY, 6, 0));
+  EXPECT_EQ(172, default_map->LookupSecondOpcode(5, VCD_COPY, 4, 0));
+  EXPECT_EQ(173, default_map->LookupSecondOpcode(5, VCD_COPY, 5, 0));
+  EXPECT_EQ(174, default_map->LookupSecondOpcode(5, VCD_COPY, 6, 0));
+  EXPECT_EQ(175, default_map->LookupSecondOpcode(2, VCD_COPY, 4, 1));
+  EXPECT_EQ(176, default_map->LookupSecondOpcode(2, VCD_COPY, 5, 1));
+  EXPECT_EQ(177, default_map->LookupSecondOpcode(2, VCD_COPY, 6, 1));
+  EXPECT_EQ(178, default_map->LookupSecondOpcode(3, VCD_COPY, 4, 1));
+  EXPECT_EQ(179, default_map->LookupSecondOpcode(3, VCD_COPY, 5, 1));
+  EXPECT_EQ(180, default_map->LookupSecondOpcode(3, VCD_COPY, 6, 1));
+  EXPECT_EQ(181, default_map->LookupSecondOpcode(4, VCD_COPY, 4, 1));
+  EXPECT_EQ(182, default_map->LookupSecondOpcode(4, VCD_COPY, 5, 1));
+  EXPECT_EQ(183, default_map->LookupSecondOpcode(4, VCD_COPY, 6, 1));
+  EXPECT_EQ(184, default_map->LookupSecondOpcode(5, VCD_COPY, 4, 1));
+  EXPECT_EQ(185, default_map->LookupSecondOpcode(5, VCD_COPY, 5, 1));
+  EXPECT_EQ(186, default_map->LookupSecondOpcode(5, VCD_COPY, 6, 1));
+  EXPECT_EQ(187, default_map->LookupSecondOpcode(2, VCD_COPY, 4, 2));
+  EXPECT_EQ(188, default_map->LookupSecondOpcode(2, VCD_COPY, 5, 2));
+  EXPECT_EQ(189, default_map->LookupSecondOpcode(2, VCD_COPY, 6, 2));
+  EXPECT_EQ(190, default_map->LookupSecondOpcode(3, VCD_COPY, 4, 2));
+  EXPECT_EQ(191, default_map->LookupSecondOpcode(3, VCD_COPY, 5, 2));
+  EXPECT_EQ(192, default_map->LookupSecondOpcode(3, VCD_COPY, 6, 2));
+  EXPECT_EQ(193, default_map->LookupSecondOpcode(4, VCD_COPY, 4, 2));
+  EXPECT_EQ(194, default_map->LookupSecondOpcode(4, VCD_COPY, 5, 2));
+  EXPECT_EQ(195, default_map->LookupSecondOpcode(4, VCD_COPY, 6, 2));
+  EXPECT_EQ(196, default_map->LookupSecondOpcode(5, VCD_COPY, 4, 2));
+  EXPECT_EQ(197, default_map->LookupSecondOpcode(5, VCD_COPY, 5, 2));
+  EXPECT_EQ(198, default_map->LookupSecondOpcode(5, VCD_COPY, 6, 2));
+  EXPECT_EQ(199, default_map->LookupSecondOpcode(2, VCD_COPY, 4, 3));
+  EXPECT_EQ(200, default_map->LookupSecondOpcode(2, VCD_COPY, 5, 3));
+  EXPECT_EQ(201, default_map->LookupSecondOpcode(2, VCD_COPY, 6, 3));
+  EXPECT_EQ(202, default_map->LookupSecondOpcode(3, VCD_COPY, 4, 3));
+  EXPECT_EQ(203, default_map->LookupSecondOpcode(3, VCD_COPY, 5, 3));
+  EXPECT_EQ(204, default_map->LookupSecondOpcode(3, VCD_COPY, 6, 3));
+  EXPECT_EQ(205, default_map->LookupSecondOpcode(4, VCD_COPY, 4, 3));
+  EXPECT_EQ(206, default_map->LookupSecondOpcode(4, VCD_COPY, 5, 3));
+  EXPECT_EQ(207, default_map->LookupSecondOpcode(4, VCD_COPY, 6, 3));
+  EXPECT_EQ(208, default_map->LookupSecondOpcode(5, VCD_COPY, 4, 3));
+  EXPECT_EQ(209, default_map->LookupSecondOpcode(5, VCD_COPY, 5, 3));
+  EXPECT_EQ(210, default_map->LookupSecondOpcode(5, VCD_COPY, 6, 3));
+  EXPECT_EQ(211, default_map->LookupSecondOpcode(2, VCD_COPY, 4, 4));
+  EXPECT_EQ(212, default_map->LookupSecondOpcode(2, VCD_COPY, 5, 4));
+  EXPECT_EQ(213, default_map->LookupSecondOpcode(2, VCD_COPY, 6, 4));
+  EXPECT_EQ(214, default_map->LookupSecondOpcode(3, VCD_COPY, 4, 4));
+  EXPECT_EQ(215, default_map->LookupSecondOpcode(3, VCD_COPY, 5, 4));
+  EXPECT_EQ(216, default_map->LookupSecondOpcode(3, VCD_COPY, 6, 4));
+  EXPECT_EQ(217, default_map->LookupSecondOpcode(4, VCD_COPY, 4, 4));
+  EXPECT_EQ(218, default_map->LookupSecondOpcode(4, VCD_COPY, 5, 4));
+  EXPECT_EQ(219, default_map->LookupSecondOpcode(4, VCD_COPY, 6, 4));
+  EXPECT_EQ(220, default_map->LookupSecondOpcode(5, VCD_COPY, 4, 4));
+  EXPECT_EQ(221, default_map->LookupSecondOpcode(5, VCD_COPY, 5, 4));
+  EXPECT_EQ(222, default_map->LookupSecondOpcode(5, VCD_COPY, 6, 4));
+  EXPECT_EQ(223, default_map->LookupSecondOpcode(2, VCD_COPY, 4, 5));
+  EXPECT_EQ(224, default_map->LookupSecondOpcode(2, VCD_COPY, 5, 5));
+  EXPECT_EQ(225, default_map->LookupSecondOpcode(2, VCD_COPY, 6, 5));
+  EXPECT_EQ(226, default_map->LookupSecondOpcode(3, VCD_COPY, 4, 5));
+  EXPECT_EQ(227, default_map->LookupSecondOpcode(3, VCD_COPY, 5, 5));
+  EXPECT_EQ(228, default_map->LookupSecondOpcode(3, VCD_COPY, 6, 5));
+  EXPECT_EQ(229, default_map->LookupSecondOpcode(4, VCD_COPY, 4, 5));
+  EXPECT_EQ(230, default_map->LookupSecondOpcode(4, VCD_COPY, 5, 5));
+  EXPECT_EQ(231, default_map->LookupSecondOpcode(4, VCD_COPY, 6, 5));
+  EXPECT_EQ(232, default_map->LookupSecondOpcode(5, VCD_COPY, 4, 5));
+  EXPECT_EQ(233, default_map->LookupSecondOpcode(5, VCD_COPY, 5, 5));
+  EXPECT_EQ(234, default_map->LookupSecondOpcode(5, VCD_COPY, 6, 5));
+
+  EXPECT_EQ(235, default_map->LookupSecondOpcode(2, VCD_COPY, 4, 6));
+  EXPECT_EQ(236, default_map->LookupSecondOpcode(3, VCD_COPY, 4, 6));
+  EXPECT_EQ(237, default_map->LookupSecondOpcode(4, VCD_COPY, 4, 6));
+  EXPECT_EQ(238, default_map->LookupSecondOpcode(5, VCD_COPY, 4, 6));
+  EXPECT_EQ(239, default_map->LookupSecondOpcode(2, VCD_COPY, 4, 7));
+  EXPECT_EQ(240, default_map->LookupSecondOpcode(3, VCD_COPY, 4, 7));
+  EXPECT_EQ(241, default_map->LookupSecondOpcode(4, VCD_COPY, 4, 7));
+  EXPECT_EQ(242, default_map->LookupSecondOpcode(5, VCD_COPY, 4, 7));
+  EXPECT_EQ(243, default_map->LookupSecondOpcode(2, VCD_COPY, 4, 8));
+  EXPECT_EQ(244, default_map->LookupSecondOpcode(3, VCD_COPY, 4, 8));
+  EXPECT_EQ(245, default_map->LookupSecondOpcode(4, VCD_COPY, 4, 8));
+  EXPECT_EQ(246, default_map->LookupSecondOpcode(5, VCD_COPY, 4, 8));
+
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(2, VCD_COPY, 0, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(2, VCD_COPY, 255, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(2, VCD_COPY, 255, 255));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(0, VCD_COPY, 4, 0));
+  EXPECT_EQ(kNoOpcode, default_map->LookupSecondOpcode(255, VCD_COPY, 4, 0));
+}
+
+TEST_F(EncodeTableTest, ExerciseTableLookup) {
+  int opcode = 0;
+  // This loop has the same bounds as the one in SetUpTestCase.
+  // Look up each instruction type and make sure it returns
+  // the proper opcode.
+  for (unsigned char inst_mode1 = 0;
+       inst_mode1 <= VCD_LAST_INSTRUCTION_TYPE + kLastExerciseMode;
+       ++inst_mode1) {
+    unsigned char inst1 = inst_mode1;
+    unsigned char mode1 = 0;
+    if (inst_mode1 > VCD_COPY) {
+      inst1 = VCD_COPY;
+      mode1 = inst_mode1 - VCD_COPY;
+    }
+    for (unsigned char inst_mode2 = 0;
+         inst_mode2 <= VCD_LAST_INSTRUCTION_TYPE + kLastExerciseMode;
+         ++inst_mode2) {
+      unsigned char inst2 = inst_mode2;
+      unsigned char mode2 = 0;
+      if (inst_mode2 > VCD_COPY) {
+        inst2 = VCD_COPY;
+        mode2 = inst_mode2 - VCD_COPY;
+      }
+      if (inst2 == VCD_NOOP) {
+        VerifyExerciseFirstInstruction(opcode, inst1, 0, mode1);
+        VerifyExerciseFirstInstruction(opcode + 2,
+                                       inst1,
+                                       ((inst1 == VCD_NOOP) ? 0 : 255),
+                                       mode1);
+      } else if (inst1 != VCD_NOOP) {
+        VerifyExerciseSecondInstruction(opcode,
+                                        inst1,
+                                        0,
+                                        mode1,
+                                        inst2,
+                                        0,
+                                        mode2);
+        VerifyExerciseSecondInstruction(opcode + 1,
+                                        inst1,
+                                        0,
+                                        mode1,
+                                        inst2,
+                                        255,
+                                        mode2);
+        VerifyExerciseSecondInstruction(opcode + 2,
+                                        inst1,
+                                        255,
+                                        mode1,
+                                        inst2,
+                                        0,
+                                        mode2);
+        VerifyExerciseSecondInstruction(opcode + 3,
+                                        inst1,
+                                        255,
+                                        mode1,
+                                        inst2,
+                                        255,
+                                        mode2);
+      }
+      opcode += 4;
+    }
+  }
+  // This is a CHECK rather than an EXPECT because it validates only
+  // the logic of the test, not of the code being tested.
+  CHECK_EQ(VCDiffCodeTableData::kCodeTableSize, opcode);
+}
+
+#ifdef GTEST_HAS_DEATH_TEST
+TEST_F(EncodeTableDeathTest, WriterAddWithoutInit) {
+#ifndef NDEBUG
+  // This condition is only checked in the debug build.
+  EXPECT_DEBUG_DEATH(standard_writer.Add("Hello", 5),
+                     "Init");
+#endif  // !NDEBUG
+}
+
+TEST_F(EncodeTableDeathTest, WriterRunWithoutInit) {
+#ifndef NDEBUG
+  // This condition is only checked in the debug build.
+  EXPECT_DEBUG_DEATH(standard_writer.Run(3, 'a'),
+                     "Init");
+#endif  // !NDEBUG
+}
+
+TEST_F(EncodeTableDeathTest, WriterCopyWithoutInit) {
+#ifndef NDEBUG
+  // This condition is only checked in the debug build.
+  EXPECT_DEBUG_DEATH(standard_writer.Copy(6, 5),
+                     "Init");
+#endif  // !NDEBUG
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Output() without Init() is harmless, but will produce no output.
+TEST_F(EncodeTableTest, WriterOutputWithoutInit) {
+  standard_writer.Output(&output_string);
+  EXPECT_TRUE(out.empty());
+}
+
+TEST_F(EncodeTableTest, WriterEncodeNothing) {
+  EXPECT_TRUE(standard_writer.Init(0));
+  standard_writer.Output(&output_string);
+  // The writer should know not to append a delta file window
+  // if nothing was encoded.
+  EXPECT_TRUE(out.empty());
+
+  out.clear();
+  EXPECT_TRUE(interleaved_writer.Init(0x10));
+  interleaved_writer.Output(&output_string);
+  EXPECT_TRUE(out.empty());
+
+  out.clear();
+  EXPECT_TRUE(exercise_writer.Init(0x20));
+  exercise_writer.Output(&output_string);
+  EXPECT_TRUE(out.empty());
+
+  ExpectNoMatches();
+}
+
+TEST_F(EncodeTableTest, StandardWriterEncodeAdd) {
+  EXPECT_TRUE(standard_writer.Init(0x11));
+  standard_writer.Add("foo", 3);
+  standard_writer.Output(&output_string);
+  ExpectByte(VCD_SOURCE);  // Win_Indicator: VCD_SOURCE (dictionary)
+  ExpectByte(0x11);  // Source segment size: dictionary length
+  ExpectByte(0x00);  // Source segment position: start of dictionary
+  ExpectByte(0x09);  // Length of the delta encoding
+  ExpectByte(0x03);  // Size of the target window
+  ExpectByte(0x00);  // Delta_indicator (no compression)
+  ExpectByte(0x03);  // length of data for ADDs and RUNs
+  ExpectByte(0x01);  // length of instructions section
+  ExpectByte(0x00);  // length of addresses for COPYs
+  ExpectString("foo");
+  ExpectByte(0x04);  // ADD(3) opcode
+  ExpectNoMoreBytes();
+  ExpectNoMatches();
+}
+
+TEST_F(EncodeTableTest, ExerciseWriterEncodeAdd) {
+  EXPECT_TRUE(exercise_writer.Init(0x11));
+  exercise_writer.Add("foo", 3);
+  exercise_writer.Output(&output_string);
+  ExpectByte(VCD_SOURCE);  // Win_Indicator: VCD_SOURCE (dictionary)
+  ExpectByte(0x11);  // Source segment size: dictionary length
+  ExpectByte(0x00);  // Source segment position: start of dictionary
+  ExpectByte(0x0A);  // Length of the delta encoding
+  ExpectByte(0x03);  // Size of the target window
+  ExpectByte(0x00);  // Delta_indicator (no compression)
+  ExpectByte(0x00);  // length of data for ADDs and RUNs
+  ExpectByte(0x05);  // length of instructions section
+  ExpectByte(0x00);  // length of addresses for COPYs
+  ExpectByte(0x04);  // Opcode: NOOP + ADD(0)
+  ExpectByte(0x03);  // Size of ADD (3)
+  ExpectString("foo");
+  ExpectNoMatches();
+}
+
+TEST_F(EncodeTableTest, StandardWriterEncodeRun) {
+  EXPECT_TRUE(standard_writer.Init(0x11));
+  standard_writer.Run(3, 'a');
+  standard_writer.Output(&output_string);
+  ExpectByte(VCD_SOURCE);  // Win_Indicator: VCD_SOURCE (dictionary)
+  ExpectByte(0x11);  // Source segment size: dictionary length
+  ExpectByte(0x00);  // Source segment position: start of dictionary
+  ExpectByte(0x08);  // Length of the delta encoding
+  ExpectByte(0x03);  // Size of the target window
+  ExpectByte(0x00);  // Delta_indicator (no compression)
+  ExpectByte(0x01);  // length of data for ADDs and RUNs
+  ExpectByte(0x02);  // length of instructions section
+  ExpectByte(0x00);  // length of addresses for COPYs
+  ExpectByte('a');
+  ExpectByte(0x00);  // RUN(0) opcode
+  ExpectByte(0x03);  // Size of RUN (3)
+  ExpectNoMoreBytes();
+  ExpectNoMatches();
+}
+
+TEST_F(EncodeTableTest, ExerciseWriterEncodeRun) {
+  EXPECT_TRUE(exercise_writer.Init(0x11));
+  exercise_writer.Run(3, 'a');
+  exercise_writer.Output(&output_string);
+  ExpectByte(VCD_SOURCE);  // Win_Indicator: VCD_SOURCE (dictionary)
+  ExpectByte(0x11);  // Source segment size: dictionary length
+  ExpectByte(0x00);  // Source segment position: start of dictionary
+  ExpectByte(0x08);  // Length of the delta encoding
+  ExpectByte(0x03);  // Size of the target window
+  ExpectByte(0x00);  // Delta_indicator (no compression)
+  ExpectByte(0x00);  // length of data for ADDs and RUNs
+  ExpectByte(0x03);  // length of instructions section
+  ExpectByte(0x00);  // length of addresses for COPYs
+  ExpectByte(0x08);  // Opcode: NOOP + RUN(0)
+  ExpectByte(0x03);  // Size of RUN (3)
+  ExpectByte('a');
+  ExpectNoMoreBytes();
+  ExpectNoMatches();
+}
+
+TEST_F(EncodeTableTest, StandardWriterEncodeCopy) {
+  EXPECT_TRUE(standard_writer.Init(0x11));
+  standard_writer.Copy(2, 8);
+  standard_writer.Copy(2, 8);
+  standard_writer.Output(&output_string);
+  ExpectByte(VCD_SOURCE);  // Win_Indicator: VCD_SOURCE (dictionary)
+  ExpectByte(0x11);  // Source segment size: dictionary length
+  ExpectByte(0x00);  // Source segment position: start of dictionary
+  ExpectByte(0x09);  // Length of the delta encoding
+  ExpectByte(0x10);  // Size of the target window
+  ExpectByte(0x00);  // Delta_indicator (no compression)
+  ExpectByte(0x00);  // length of data for ADDs and RUNs
+  ExpectByte(0x02);  // length of instructions section
+  ExpectByte(0x02);  // length of addresses for COPYs
+  ExpectByte(0x18);  // COPY mode SELF, size 8
+  ExpectByte(0x78);  // COPY mode SAME(0), size 8
+  ExpectByte(0x02);  // COPY address (2)
+  ExpectByte(0x02);  // COPY address (2)
+  ExpectNoMoreBytes();
+  EXPECT_LE(9U, standard_writer.match_counts().size());
+  EXPECT_EQ(0, standard_writer.match_counts()[0]);
+  EXPECT_EQ(0, standard_writer.match_counts()[1]);
+  EXPECT_EQ(0, standard_writer.match_counts()[2]);
+  EXPECT_EQ(0, standard_writer.match_counts()[3]);
+  EXPECT_EQ(0, standard_writer.match_counts()[4]);
+  EXPECT_EQ(0, standard_writer.match_counts()[5]);
+  EXPECT_EQ(0, standard_writer.match_counts()[6]);
+  EXPECT_EQ(0, standard_writer.match_counts()[7]);
+  EXPECT_EQ(2, standard_writer.match_counts()[8]);
+}
+
+// The exercise code table can't be used to test how the code table
+// writer encodes COPY instructions because the code table writer
+// always uses the default cache sizes, which exceed the maximum mode
+// used in the exercise table.
+TEST_F(EncodeTableTest, InterleavedWriterEncodeCopy) {
+  EXPECT_TRUE(interleaved_writer.Init(0x11));
+  interleaved_writer.Copy(2, 8);
+  interleaved_writer.Copy(2, 8);
+  interleaved_writer.Output(&output_string);
+  ExpectByte(VCD_SOURCE);  // Win_Indicator: VCD_SOURCE (dictionary)
+  ExpectByte(0x11);  // Source segment size: dictionary length
+  ExpectByte(0x00);  // Source segment position: start of dictionary
+  ExpectByte(0x09);  // Length of the delta encoding
+  ExpectByte(0x10);  // Size of the target window
+  ExpectByte(0x00);  // Delta_indicator (no compression)
+  ExpectByte(0x00);  // length of data for ADDs and RUNs
+  ExpectByte(0x04);  // length of instructions section
+  ExpectByte(0x00);  // length of addresses for COPYs
+  ExpectByte(0x18);  // COPY mode SELF, size 8
+  ExpectByte(0x02);  // COPY address (2)
+  ExpectByte(0x78);  // COPY mode SAME(0), size 8
+  ExpectByte(0x02);  // COPY address (2)
+  ExpectNoMoreBytes();
+  EXPECT_LE(9U, interleaved_writer.match_counts().size());
+  EXPECT_EQ(0, interleaved_writer.match_counts()[0]);
+  EXPECT_EQ(0, interleaved_writer.match_counts()[1]);
+  EXPECT_EQ(0, interleaved_writer.match_counts()[2]);
+  EXPECT_EQ(0, interleaved_writer.match_counts()[3]);
+  EXPECT_EQ(0, interleaved_writer.match_counts()[4]);
+  EXPECT_EQ(0, interleaved_writer.match_counts()[5]);
+  EXPECT_EQ(0, interleaved_writer.match_counts()[6]);
+  EXPECT_EQ(0, interleaved_writer.match_counts()[7]);
+  EXPECT_EQ(2, interleaved_writer.match_counts()[8]);
+}
+
+TEST_F(EncodeTableTest, StandardWriterEncodeCombo) {
+  EXPECT_TRUE(standard_writer.Init(0x11));
+  standard_writer.Add("rayo", 4);
+  standard_writer.Copy(2, 5);
+  standard_writer.Copy(0, 4);
+  standard_writer.Add("X", 1);
+  standard_writer.Output(&output_string);
+  ExpectByte(VCD_SOURCE);  // Win_Indicator: VCD_SOURCE (dictionary)
+  ExpectByte(0x11);  // Source segment size: dictionary length
+  ExpectByte(0x00);  // Source segment position: start of dictionary
+  ExpectByte(0x0E);  // Length of the delta encoding
+  ExpectByte(0x0E);  // Size of the target window
+  ExpectByte(0x00);  // Delta_indicator (no compression)
+  ExpectByte(0x05);  // length of data for ADDs and RUNs
+  ExpectByte(0x02);  // length of instructions section
+  ExpectByte(0x02);  // length of addresses for COPYs
+  ExpectString("rayoX");
+  ExpectByte(0xAD);  // Combo: Add size 4 + COPY mode SELF, size 5
+  ExpectByte(0xFD);  // Combo: COPY mode SAME(0), size 4 + Add size 1
+  ExpectByte(0x02);  // COPY address (2)
+  ExpectByte(0x00);  // COPY address (0)
+  ExpectNoMoreBytes();
+  EXPECT_LE(6U, standard_writer.match_counts().size());
+  EXPECT_EQ(0, standard_writer.match_counts()[0]);
+  EXPECT_EQ(0, standard_writer.match_counts()[1]);
+  EXPECT_EQ(0, standard_writer.match_counts()[2]);
+  EXPECT_EQ(0, standard_writer.match_counts()[3]);
+  EXPECT_EQ(1, standard_writer.match_counts()[4]);
+  EXPECT_EQ(1, standard_writer.match_counts()[5]);
+}
+
+TEST_F(EncodeTableTest, InterleavedWriterEncodeCombo) {
+  EXPECT_TRUE(interleaved_writer.Init(0x11));
+  interleaved_writer.Add("rayo", 4);
+  interleaved_writer.Copy(2, 5);
+  interleaved_writer.Copy(0, 4);
+  interleaved_writer.Add("X", 1);
+  interleaved_writer.Output(&output_string);
+  ExpectByte(VCD_SOURCE);  // Win_Indicator: VCD_SOURCE (dictionary)
+  ExpectByte(0x11);  // Source segment size: dictionary length
+  ExpectByte(0x00);  // Source segment position: start of dictionary
+  ExpectByte(0x0E);  // Length of the delta encoding
+  ExpectByte(0x0E);  // Size of the target window
+  ExpectByte(0x00);  // Delta_indicator (no compression)
+  ExpectByte(0x00);  // length of data for ADDs and RUNs
+  ExpectByte(0x09);  // length of instructions section
+  ExpectByte(0x00);  // length of addresses for COPYs
+  ExpectByte(0xAD);  // Combo: Add size 4 + COPY mode SELF, size 5
+  ExpectString("rayo");
+  ExpectByte(0x02);  // COPY address (2)
+  ExpectByte(0xFD);  // Combo: COPY mode SAME(0), size 4 + Add size 1
+  ExpectByte(0x00);  // COPY address (0)
+  ExpectByte('X');
+  ExpectNoMoreBytes();
+  EXPECT_LE(6U, interleaved_writer.match_counts().size());
+  EXPECT_EQ(0, interleaved_writer.match_counts()[0]);
+  EXPECT_EQ(0, interleaved_writer.match_counts()[1]);
+  EXPECT_EQ(0, interleaved_writer.match_counts()[2]);
+  EXPECT_EQ(0, interleaved_writer.match_counts()[3]);
+  EXPECT_EQ(1, interleaved_writer.match_counts()[4]);
+  EXPECT_EQ(1, interleaved_writer.match_counts()[5]);
+}
+
+TEST_F(EncodeTableTest, InterleavedWriterEncodeComboWithChecksum) {
+  EXPECT_TRUE(interleaved_writer.Init(0x11));
+  const VCDChecksum checksum = 0xFFFFFFFF;  // would be negative if signed
+  interleaved_writer.AddChecksum(checksum);
+  interleaved_writer.Add("rayo", 4);
+  interleaved_writer.Copy(2, 5);
+  interleaved_writer.Copy(0, 4);
+  interleaved_writer.Add("X", 1);
+  interleaved_writer.Output(&output_string);
+  ExpectByte(VCD_SOURCE | VCD_CHECKSUM);  // Win_Indicator
+  ExpectByte(0x11);  // Source segment size: dictionary length
+  ExpectByte(0x00);  // Source segment position: start of dictionary
+  ExpectByte(0x13);  // Length of the delta encoding
+  ExpectByte(0x0E);  // Size of the target window
+  ExpectByte(0x00);  // Delta_indicator (no compression)
+  ExpectByte(0x00);  // length of data for ADDs and RUNs
+  ExpectByte(0x09);  // length of instructions section
+  ExpectByte(0x00);  // length of addresses for COPYs
+  ExpectByte(0x8F);  // checksum byte 1
+  ExpectByte(0xFF);  // checksum byte 2
+  ExpectByte(0xFF);  // checksum byte 3
+  ExpectByte(0xFF);  // checksum byte 4
+  ExpectByte(0x7F);  // checksum byte 5
+  ExpectByte(0xAD);  // Combo: Add size 4 + COPY mode SELF, size 5
+  ExpectString("rayo");
+  ExpectByte(0x02);  // COPY address (2)
+  ExpectByte(0xFD);  // Combo: COPY mode SAME(0), size 4 + Add size 1
+  ExpectByte(0x00);  // COPY address (0)
+  ExpectByte('X');
+  ExpectNoMoreBytes();
+}
+
+TEST_F(EncodeTableTest, ReallyBigDictionary) {
+  EXPECT_TRUE(interleaved_writer.Init(0x3FFFFFFF));
+  interleaved_writer.Copy(2, 8);
+  interleaved_writer.Copy(0x3FFFFFFE, 8);
+  interleaved_writer.Output(&output_string);
+  ExpectByte(VCD_SOURCE);  // Win_Indicator: VCD_SOURCE (dictionary)
+  ExpectByte(0x83);  // Source segment size: dictionary length (1)
+  ExpectByte(0xFF);  // Source segment size: dictionary length (2)
+  ExpectByte(0xFF);  // Source segment size: dictionary length (3)
+  ExpectByte(0xFF);  // Source segment size: dictionary length (4)
+  ExpectByte(0x7F);  // Source segment size: dictionary length (5)
+  ExpectByte(0x00);  // Source segment position: start of dictionary
+  ExpectByte(0x09);  // Length of the delta encoding
+  ExpectByte(0x10);  // Size of the target window
+  ExpectByte(0x00);  // Delta_indicator (no compression)
+  ExpectByte(0x00);  // length of data for ADDs and RUNs
+  ExpectByte(0x04);  // length of instructions section
+  ExpectByte(0x00);  // length of addresses for COPYs
+  ExpectByte(0x18);  // COPY mode SELF, size 8
+  ExpectByte(0x02);  // COPY address (2)
+  ExpectByte(0x28);  // COPY mode HERE, size 8
+  ExpectByte(0x09);  // COPY address (9)
+  ExpectNoMoreBytes();
+  EXPECT_LE(9U, interleaved_writer.match_counts().size());
+  EXPECT_EQ(0, interleaved_writer.match_counts()[0]);
+  EXPECT_EQ(0, interleaved_writer.match_counts()[1]);
+  EXPECT_EQ(0, interleaved_writer.match_counts()[2]);
+  EXPECT_EQ(0, interleaved_writer.match_counts()[3]);
+  EXPECT_EQ(0, interleaved_writer.match_counts()[4]);
+  EXPECT_EQ(0, interleaved_writer.match_counts()[5]);
+  EXPECT_EQ(0, interleaved_writer.match_counts()[6]);
+  EXPECT_EQ(0, interleaved_writer.match_counts()[7]);
+  EXPECT_EQ(2, interleaved_writer.match_counts()[8]);
+}
+
+#ifdef GTEST_HAS_DEATH_TEST
+TEST_F(EncodeTableDeathTest, DictionaryTooBig) {
+  EXPECT_TRUE(interleaved_writer.Init(0x7FFFFFFF));
+  interleaved_writer.Copy(2, 8);
+  EXPECT_DEBUG_DEATH(interleaved_writer.Copy(0x7FFFFFFE, 8),
+                     "address.*<.*here_address");
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+}  // unnamed namespace
+}  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gflags.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gflags.cc
new file mode 100644
index 0000000..37879c9
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gflags.cc
@@ -0,0 +1,1963 @@
+// Copyright (c) 2006, 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.
+
+// ---
+// Author: Ray Sidney
+// Revamped and reorganized by Craig Silverstein
+//
+// This file contains the implementation of all our command line flags
+// stuff.  Here's how everything fits together
+//
+// * FlagRegistry owns CommandLineFlags owns FlagValue.
+// * FlagSaver holds a FlagRegistry (saves it at construct time,
+//     restores it at destroy time).
+// * CommandLineFlagParser lives outside that hierarchy, but works on
+//     CommandLineFlags (modifying the FlagValues).
+// * Free functions like SetCommandLineOption() work via one of the
+//     above (such as CommandLineFlagParser).
+//
+// In more detail:
+//
+// -- The main classes that hold flag data:
+//
+// FlagValue holds the current value of a flag.  It's
+// pseudo-templatized: every operation on a FlagValue is typed.  It
+// also deals with storage-lifetime issues (so flag values don't go
+// away in a destructor), which is why we need a whole class to hold a
+// variable's value.
+//
+// CommandLineFlag is all the information about a single command-line
+// flag.  It has a FlagValue for the flag's current value, but also
+// the flag's name, type, etc.
+//
+// FlagRegistry is a collection of CommandLineFlags.  There's the
+// global registry, which is where flags defined via DEFINE_foo()
+// live.  But it's possible to define your own flag, manually, in a
+// different registry you create.  (In practice, multiple registries
+// are used only by FlagSaver).
+//
+// A given FlagValue is owned by exactly one CommandLineFlag.  A given
+// CommandLineFlag is owned by exactly one FlagRegistry.  FlagRegistry
+// has a lock; any operation that writes to a FlagValue or
+// CommandLineFlag owned by that registry must acquire the
+// FlagRegistry lock before doing so.
+//
+// --- Some other classes and free functions:
+//
+// CommandLineFlagInfo is a client-exposed version of CommandLineFlag.
+// Once it's instantiated, it has no dependencies or relationships
+// with any other part of this file.
+//
+// FlagRegisterer is the helper class used by the DEFINE_* macros to
+// allow work to be done at global initialization time.
+//
+// CommandLineFlagParser is the class that reads from the commandline
+// and instantiates flag values based on that.  It needs to poke into
+// the innards of the FlagValue->CommandLineFlag->FlagRegistry class
+// hierarchy to do that.  It's careful to acquire the FlagRegistry
+// lock before doing any writing or other non-const actions.
+//
+// GetCommandLineOption is just a hook into registry routines to
+// retrieve a flag based on its name.  SetCommandLineOption, on the
+// other hand, hooks into CommandLineFlagParser.  Other API functions
+// are, similarly, mostly hooks into the functionality described above.
+
+#include "config.h"
+#include <stdio.h>     // for snprintf
+#include <ctype.h>
+#include <errno.h>
+#include <string.h>
+#include <assert.h>
+#ifdef HAVE_FNMATCH_H
+#include <fnmatch.h>
+#endif  // HAVE_FNMATCH_H
+#ifdef HAVE_PTHREAD
+#include <pthread.h>
+#endif  // HAVE_PTHREAD
+#ifdef HAVE_WINDOWS_H
+#include <windows.h>
+#endif  // HAVE_WINDOWS_H
+#include <iostream>    // for cerr
+#include <string>
+#include <map>
+#include <vector>
+#include <utility>     // for pair<>
+#include <algorithm>
+#include "google/gflags.h"
+
+#ifndef PATH_SEPARATOR
+#define PATH_SEPARATOR  '/'
+#endif
+
+// Work properly if either strtoll or strtoq is on this system
+#ifdef HAVE_STRTOLL
+# define strtoint64  strtoll
+# define strtouint64  strtoull
+#elif HAVE_STRTOQ
+# define strtoint64  strtoq
+# define strtouint64  strtouq
+#else
+// Neither strtoll nor strtoq are defined.  I hope strtol works!
+# define strtoint64 strtol
+# define strtouint64 strtoul
+#endif
+
+using std::string;
+using std::map;
+using std::vector;
+using std::pair;
+using std::cerr;
+
+// Special flags, type 1: the 'recursive' flags.  They set another flag's val.
+DEFINE_string(flagfile, "",
+              "load flags from file");
+DEFINE_string(fromenv, "",
+              "set flags from the environment"
+              " [use 'export FLAGS_flag1=value']");
+DEFINE_string(tryfromenv, "",
+              "set flags from the environment if present");
+
+// Special flags, type 2: the 'parsing' flags.  They modify how we parse.
+DEFINE_string(undefok, "",
+              "comma-separated list of flag names that it is okay to specify "
+              "on the command line even if the program does not define a flag "
+              "with that name.  IMPORTANT: flags in this list that have "
+              "arguments MUST use the flag=value format");
+
+namespace google {
+
+// The help message indicating that the commandline flag has been
+// 'stripped'. It will not show up when doing "-help" and its
+// variants. The flag is stripped if STRIP_FLAG_HELP is set to 1
+// before including google/gflags.h.
+
+// This is used by this file, and also in commandlineflags_reporting.cc
+const char kStrippedFlagHelp[] = "\001\002\003\004 (unknown) \004\003\002\001";
+
+// This is used by the unittest to test error-exit code
+void (*commandlineflags_exitfunc)(int) = &exit;   // from stdlib.h
+
+namespace {
+
+// There are also 'reporting' flags, in commandlineflags_reporting.cc.
+
+static const char kError[] = "ERROR: ";
+
+// Indicates that undefined options are to be ignored.
+// Enables deferred processing of flags in dynamically loaded libraries.
+static bool allow_command_line_reparsing = false;
+
+static bool logging_is_probably_set_up = false;
+
+// This is a 'prototype' validate-function.  'Real' validate
+// functions, take a flag-value as an argument: ValidateFn(bool) or
+// ValidateFn(uint64).  However, for easier storage, we strip off this
+// argument and then restore it when actually calling the function on
+// a flag value.
+typedef bool (*ValidateFnProto)();
+
+
+// --------------------------------------------------------------------
+// FlagValue
+//    This represent the value a single flag might have.  The major
+//    functionality is to convert from a string to an object of a
+//    given type, and back.  Thread-compatible.
+// --------------------------------------------------------------------
+
+class FlagValue {
+ public:
+  FlagValue(void* valbuf, const char* type);
+  ~FlagValue();
+
+  bool ParseFrom(const char* spec);
+  string ToString() const;
+
+ private:
+  friend class CommandLineFlag;  // for many things, including Validate()
+  friend class ::google::FlagSaverImpl; // calls New()
+  friend class FlagRegistry;     // checks value_buffer_ for flags_by_ptr_ map
+  template <typename T> friend T GetFromEnv(const char*, const char*, T);
+  friend bool TryParseLocked(const class CommandLineFlag*, FlagValue*,
+                             const char*, string*);  // for New(), CopyFrom()
+
+  enum ValueType {FV_BOOL, FV_INT32, FV_INT64, FV_UINT64, FV_DOUBLE, FV_STRING};
+
+  const char* TypeName() const;
+  bool Equal(const FlagValue& x) const;
+  FlagValue* New() const;   // creates a new one with default value
+  void CopyFrom(const FlagValue& x);
+
+  // Calls the given validate-fn on value_buffer_, and returns
+  // whatever it returns.  But first casts validate_fn_proto to a
+  // function that takes our value as an argument (eg void
+  // (*validate_fn)(bool) for a bool flag).
+  bool Validate(const char* flagname, ValidateFnProto validate_fn_proto) const;
+
+  void* value_buffer_;          // points to the buffer holding our data
+  ValueType type_;              // how to interpret value_
+
+  FlagValue(const FlagValue&);   // no copying!
+  void operator=(const FlagValue&);
+};
+
+
+// This could be a templated method of FlagValue, but doing so adds to the
+// size of the .o.  Since there's no type-safety here anyway, macro is ok.
+#define VALUE_AS(type)  *reinterpret_cast<type*>(value_buffer_)
+#define OTHER_VALUE_AS(fv, type)  *reinterpret_cast<type*>(fv.value_buffer_)
+#define SET_VALUE_AS(type, value)  VALUE_AS(type) = (value)
+
+FlagValue::FlagValue(void* valbuf, const char* type) : value_buffer_(valbuf) {
+  if      (strcmp(type, "bool") == 0)  type_ = FV_BOOL;
+  else if (strcmp(type, "int32") == 0)  type_ = FV_INT32;
+  else if (strcmp(type, "int64") == 0)  type_ = FV_INT64;
+  else if (strcmp(type, "uint64") == 0)  type_ = FV_UINT64;
+  else if (strcmp(type, "double") == 0)  type_ = FV_DOUBLE;
+  else if (strcmp(type, "string") == 0)  type_ = FV_STRING;
+  else assert(false); // Unknown typename
+}
+
+FlagValue::~FlagValue() {
+  switch (type_) {
+    case FV_BOOL: delete reinterpret_cast<bool*>(value_buffer_); break;
+    case FV_INT32: delete reinterpret_cast<int32*>(value_buffer_); break;
+    case FV_INT64: delete reinterpret_cast<int64*>(value_buffer_); break;
+    case FV_UINT64: delete reinterpret_cast<uint64*>(value_buffer_); break;
+    case FV_DOUBLE: delete reinterpret_cast<double*>(value_buffer_); break;
+    case FV_STRING: delete reinterpret_cast<string*>(value_buffer_); break;
+  }
+}
+
+bool FlagValue::ParseFrom(const char* value) {
+  if (type_ == FV_BOOL) {
+    const char* kTrue[] = { "1", "t", "true", "y", "yes" };
+    const char* kFalse[] = { "0", "f", "false", "n", "no" };
+    for (size_t i = 0; i < sizeof(kTrue)/sizeof(*kTrue); ++i) {
+      if (strcasecmp(value, kTrue[i]) == 0) {
+        SET_VALUE_AS(bool, true);
+        return true;
+      } else if (strcasecmp(value, kFalse[i]) == 0) {
+        SET_VALUE_AS(bool, false);
+        return true;
+      }
+    }
+    return false;   // didn't match a legal input
+
+  } else if (type_ == FV_STRING) {
+    SET_VALUE_AS(string, value);
+    return true;
+  }
+
+  // OK, it's likely to be numeric, and we'll be using a strtoXXX method.
+  if (value[0] == '\0')   // empty-string is only allowed for string type.
+    return false;
+  char* end;
+  // Leading 0x puts us in base 16.  But leading 0 does not put us in base 8!
+  // It caused too many bugs when we had that behavior.
+  int base = 10;    // by default
+  if (value[0] == '0' && (value[1] == 'x' || value[1] == 'X'))
+    base = 16;
+  errno = 0;
+
+  switch (type_) {
+    case FV_INT32: {
+      const int64 r = strtoint64(value, &end, base);
+      if (errno || end != value + strlen(value))  return false;  // bad parse
+      if (static_cast<int32>(r) != r)  // worked, but number out of range
+        return false;
+      SET_VALUE_AS(int32, r);
+      return true;
+    }
+    case FV_INT64: {
+      const int64 r = strtoint64(value, &end, base);
+      if (errno || end != value + strlen(value))  return false;  // bad parse
+      SET_VALUE_AS(int64, r);
+      return true;
+    }
+    case FV_UINT64: {
+      while (*value == ' ') value++;
+      if (*value == '-') return false;  // negative number
+      const uint64 r = strtouint64(value, &end, base);
+      if (errno || end != value + strlen(value))  return false;  // bad parse
+      SET_VALUE_AS(uint64, r);
+      return true;
+    }
+    case FV_DOUBLE: {
+      const double r = strtod(value, &end);
+      if (errno || end != value + strlen(value))  return false;  // bad parse
+      SET_VALUE_AS(double, r);
+      return true;
+    }
+    default: {
+      assert(false);  // unknown type
+      return false;
+    }
+  }
+}
+
+string FlagValue::ToString() const {
+  char intbuf[64];    // enough to hold even the biggest number
+  switch (type_) {
+    case FV_BOOL:
+      return VALUE_AS(bool) ? "true" : "false";
+    case FV_INT32:
+      snprintf(intbuf, sizeof(intbuf), "%d", VALUE_AS(int32));
+      return intbuf;
+    case FV_INT64:
+      snprintf(intbuf, sizeof(intbuf), "%lld", VALUE_AS(int64));
+      return intbuf;
+    case FV_UINT64:
+      snprintf(intbuf, sizeof(intbuf), "%llu", VALUE_AS(uint64));
+      return intbuf;
+    case FV_DOUBLE:
+      snprintf(intbuf, sizeof(intbuf), "%.17g", VALUE_AS(double));
+      return intbuf;
+    case FV_STRING:
+      return VALUE_AS(string);
+    default:
+      assert(false);
+      return "";  // unknown type
+  }
+}
+
+bool FlagValue::Validate(const char* flagname,
+                         ValidateFnProto validate_fn_proto) const {
+  switch (type_) {
+    case FV_BOOL:
+      return reinterpret_cast<bool (*)(const char*, bool)>(
+          validate_fn_proto)(flagname, VALUE_AS(bool));
+    case FV_INT32:
+      return reinterpret_cast<bool (*)(const char*, int32)>(
+          validate_fn_proto)(flagname, VALUE_AS(int32));
+    case FV_INT64:
+      return reinterpret_cast<bool (*)(const char*, int64)>(
+          validate_fn_proto)(flagname, VALUE_AS(int64));
+    case FV_UINT64:
+      return reinterpret_cast<bool (*)(const char*, uint64)>(
+          validate_fn_proto)(flagname, VALUE_AS(uint64));
+    case FV_DOUBLE:
+      return reinterpret_cast<bool (*)(const char*, double)>(
+          validate_fn_proto)(flagname, VALUE_AS(double));
+    case FV_STRING:
+      return reinterpret_cast<bool (*)(const char*, const string&)>(
+          validate_fn_proto)(flagname, VALUE_AS(string));
+    default:
+      assert(false);  // unknown type
+      return false;
+  }
+}
+
+const char* FlagValue::TypeName() const {
+  switch (type_) {
+    case FV_BOOL:   return "bool";
+    case FV_INT32:  return "int32";
+    case FV_INT64:  return "int64";
+    case FV_UINT64: return "uint64";
+    case FV_DOUBLE: return "double";
+    case FV_STRING: return "string";
+    default: assert(false); return "";  // unknown type
+  }
+}
+
+bool FlagValue::Equal(const FlagValue& x) const {
+  if (type_ != x.type_)
+    return false;
+  switch (type_) {
+    case FV_BOOL:   return VALUE_AS(bool) == OTHER_VALUE_AS(x, bool);
+    case FV_INT32:  return VALUE_AS(int32) == OTHER_VALUE_AS(x, int32);
+    case FV_INT64:  return VALUE_AS(int64) == OTHER_VALUE_AS(x, int64);
+    case FV_UINT64: return VALUE_AS(uint64) == OTHER_VALUE_AS(x, uint64);
+    case FV_DOUBLE: return VALUE_AS(double) == OTHER_VALUE_AS(x, double);
+    case FV_STRING: return VALUE_AS(string) == OTHER_VALUE_AS(x, string);
+    default: assert(false); return false;  // unknown type
+  }
+}
+
+FlagValue* FlagValue::New() const {
+  switch (type_) {
+    case FV_BOOL:   return new FlagValue(new bool, "bool");
+    case FV_INT32:  return new FlagValue(new int32, "int32");
+    case FV_INT64:  return new FlagValue(new int64, "int64");
+    case FV_UINT64: return new FlagValue(new uint64, "uint64");
+    case FV_DOUBLE: return new FlagValue(new double, "double");
+    case FV_STRING: return new FlagValue(new string, "string");
+    default: assert(false); return NULL;  // unknown type
+  }
+}
+
+void FlagValue::CopyFrom(const FlagValue& x) {
+  assert(type_ == x.type_);
+  switch (type_) {
+    case FV_BOOL:   SET_VALUE_AS(bool, OTHER_VALUE_AS(x, bool));      break;
+    case FV_INT32:  SET_VALUE_AS(int32, OTHER_VALUE_AS(x, int32));    break;
+    case FV_INT64:  SET_VALUE_AS(int64, OTHER_VALUE_AS(x, int64));    break;
+    case FV_UINT64: SET_VALUE_AS(uint64, OTHER_VALUE_AS(x, uint64));  break;
+    case FV_DOUBLE: SET_VALUE_AS(double, OTHER_VALUE_AS(x, double));  break;
+    case FV_STRING: SET_VALUE_AS(string, OTHER_VALUE_AS(x, string));  break;
+    default: assert(false);  // unknown type
+  }
+}
+
+// --------------------------------------------------------------------
+// CommandLineFlag
+//    This represents a single flag, including its name, description,
+//    default value, and current value.  Mostly this serves as a
+//    struct, though it also knows how to register itself.
+//       All CommandLineFlags are owned by a (exactly one)
+//    FlagRegistry.  If you wish to modify fields in this class, you
+//    should acquire the FlagRegistry lock for the registry that owns
+//    this flag.
+// --------------------------------------------------------------------
+
+class CommandLineFlag {
+ public:
+  // Note: we take over memory-ownership of current_val and default_val.
+  CommandLineFlag(const char* name, const char* help, const char* filename,
+                  FlagValue* current_val, FlagValue* default_val);
+  ~CommandLineFlag();
+
+  const char* name() const { return name_; }
+  const char* help() const { return help_; }
+  const char* filename() const { return file_; }
+  const char* CleanFileName() const;  // nixes irrelevant prefix such as homedir
+  string current_value() const { return current_->ToString(); }
+  string default_value() const { return defvalue_->ToString(); }
+  const char* type_name() const { return defvalue_->TypeName(); }
+  ValidateFnProto validate_function() const { return validate_fn_proto_; }
+
+  void FillCommandLineFlagInfo(struct CommandLineFlagInfo* result);
+
+  // If validate_fn_proto_ is non-NULL, calls it on value, returns result.
+  bool Validate(const FlagValue& value) const;
+  bool ValidateCurrent() const { return Validate(*current_); }
+
+ private:
+  // for SetFlagLocked() and setting flags_by_ptr_
+  friend class FlagRegistry;
+  friend class ::google::FlagSaverImpl;  // for cloning the values
+  friend bool GetCommandLineOption(const char*, string*, bool*);
+  // set validate_fn
+  friend bool AddFlagValidator(const void*, ValidateFnProto);
+
+  // This copies all the non-const members: modified, processed, defvalue, etc.
+  void CopyFrom(const CommandLineFlag& src);
+
+  void UpdateModifiedBit();
+
+  const char* const name_;     // Flag name
+  const char* const help_;     // Help message
+  const char* const file_;     // Which file did this come from?
+  bool modified_;              // Set after default assignment?
+  FlagValue* defvalue_;        // Default value for flag
+  FlagValue* current_;         // Current value for flag
+  // This is a casted, 'generic' version of validate_fn, which actually
+  // takes a flag-value as an arg (void (*validate_fn)(bool), say).
+  // When we pass this to current_->Validate(), it will cast it back to
+  // the proper type.  This may be NULL to mean we have no validate_fn.
+  ValidateFnProto validate_fn_proto_;
+
+  CommandLineFlag(const CommandLineFlag&);   // no copying!
+  void operator=(const CommandLineFlag&);
+};
+
+CommandLineFlag::CommandLineFlag(const char* name, const char* help,
+                                 const char* filename,
+                                 FlagValue* current_val, FlagValue* default_val)
+    : name_(name), help_(help), file_(filename), modified_(false),
+      defvalue_(default_val), current_(current_val), validate_fn_proto_(NULL) {
+}
+
+CommandLineFlag::~CommandLineFlag() {
+  delete current_;
+  delete defvalue_;
+}
+
+const char* CommandLineFlag::CleanFileName() const {
+  // Compute top-level directory & file that this appears in
+  // search full path backwards.
+  // Stop going backwards at kRootDir; and skip by the first slash.
+  static const char kRootDir[] = "";    // can set this to root directory,
+                                        // e.g. "myproject"
+
+  if (sizeof(kRootDir)-1 == 0)          // no prefix to strip
+    return filename();
+
+  const char* clean_name = filename() + strlen(filename()) - 1;
+  while ( clean_name > filename() ) {
+    if (*clean_name == PATH_SEPARATOR) {
+      if (strncmp(clean_name, kRootDir, sizeof(kRootDir)-1) == 0) {
+        // ".../myproject/base/logging.cc" ==> "base/logging.cc"
+        clean_name += sizeof(kRootDir)-1;    // past "/myproject/"
+        break;
+      }
+    }
+    --clean_name;
+  }
+  while ( *clean_name == PATH_SEPARATOR ) ++clean_name;  // Skip any slashes
+  return clean_name;
+}
+
+void CommandLineFlag::FillCommandLineFlagInfo(
+    CommandLineFlagInfo* result) {
+  result->name = name();
+  result->type = type_name();
+  result->description = help();
+  result->current_value = current_value();
+  result->default_value = default_value();
+  result->filename = CleanFileName();
+  UpdateModifiedBit();
+  result->is_default = !modified_;
+  result->has_validator_fn = validate_function() != NULL;
+}
+
+void CommandLineFlag::UpdateModifiedBit() {
+  // Update the "modified" bit in case somebody bypassed the
+  // Flags API and wrote directly through the FLAGS_name variable.
+  if (!modified_ && !current_->Equal(*defvalue_)) {
+    modified_ = true;
+  }
+}
+
+void CommandLineFlag::CopyFrom(const CommandLineFlag& src) {
+  // Note we only copy the non-const members; others are fixed at construct time
+  modified_ = src.modified_;
+  current_->CopyFrom(*src.current_);
+  defvalue_->CopyFrom(*src.defvalue_);
+  validate_fn_proto_ = src.validate_fn_proto_;
+}
+
+bool CommandLineFlag::Validate(const FlagValue& value) const {
+  if (validate_function() == NULL)
+    return true;
+  else
+    return value.Validate(name(), validate_function());
+}
+
+
+// --------------------------------------------------------------------
+// FlagRegistry
+//    A FlagRegistry singleton object holds all flag objects indexed
+//    by their names so that if you know a flag's name (as a C
+//    string), you can access or set it.  If the function is named
+//    FooLocked(), you must own the registry lock before calling
+//    the function; otherwise, you should *not* hold the lock, and
+//    the function will acquire it itself if needed.
+// --------------------------------------------------------------------
+
+struct StringCmp {  // Used by the FlagRegistry map class to compare char*'s
+  bool operator() (const char* s1, const char* s2) const {
+    return (strcmp(s1, s2) < 0);
+  }
+};
+
+class FlagRegistry {
+ public:
+  FlagRegistry();
+  ~FlagRegistry();
+
+  void Lock();
+  void Unlock();
+
+  // Store a flag in this registry.  Takes ownership of the given pointer.
+  void RegisterFlag(CommandLineFlag* flag);
+
+  // Returns the flag object for the specified name, or NULL if not found.
+  CommandLineFlag* FindFlagLocked(const char* name);
+
+  // Returns the flag object whose current-value is stored at flag_ptr.
+  // That is, for whom current_->value_buffer_ == flag_ptr
+  CommandLineFlag* FindFlagViaPtrLocked(const void* flag_ptr);
+
+  // A fancier form of FindFlag that works correctly if name is of the
+  // form flag=value.  In that case, we set key to point to flag, and
+  // modify v to point to the value (if present), and return the flag
+  // with the given name.  If the flag does not exist, returns NULL
+  // and sets error_message.
+  CommandLineFlag* SplitArgumentLocked(const char* argument,
+                                       string* key, const char** v,
+                                       string* error_message);
+
+  // Set the value of a flag.  If the flag was successfully set to
+  // value, set msg to indicate the new flag-value, and return true.
+  // Otherwise, set msg to indicate the error, leave flag unchanged,
+  // and return false.  msg can be NULL.
+  bool SetFlagLocked(CommandLineFlag* flag, const char* value,
+                     FlagSettingMode set_mode, string* msg);
+
+  static FlagRegistry* GlobalRegistry();   // returns a singleton registry
+
+ private:
+  friend class ::google::FlagSaverImpl;  // reads all the flags in order to copy them
+  friend class CommandLineFlagParser;    // for ValidateAllFlags
+  friend void ::google::GetAllFlags(vector<CommandLineFlagInfo>*);
+
+  // The map from name to flag, for FindFlagLocked().
+  typedef map<const char*, CommandLineFlag*, StringCmp> FlagMap;
+  typedef FlagMap::iterator FlagIterator;
+  typedef FlagMap::const_iterator FlagConstIterator;
+  FlagMap flags_;
+
+  // The map from current-value pointer to flag, fo FindFlagViaPtrLocked().
+  typedef map<const void*, CommandLineFlag*> FlagPtrMap;
+  FlagPtrMap flags_by_ptr_;
+
+#if defined(HAVE_PTHREAD)
+  pthread_mutex_t lock_;
+#elif defined(HAVE_INITIALIZECRITICALSECTION)
+  CRITICAL_SECTION lock_;
+#else
+#error "Need to define a mutual-exclusion object for your system"
+#endif
+
+  static FlagRegistry* global_registry_;   // a singleton registry
+
+  // If global_registry_ has not yet been initialized, this function allocates
+  // a new global registry.  If InterlockedCompareExchange() is available, it
+  // does so in a thread-safe manner; otherwise, single-threaded execution (or
+  // serialization using pthread_once) is assumed.
+  static void InitGlobalRegistry();
+
+  // Disallow
+  FlagRegistry(const FlagRegistry&);
+  FlagRegistry& operator=(const FlagRegistry&);
+};
+
+class FlagRegistryLock {
+ public:
+  explicit FlagRegistryLock(FlagRegistry* fr) : fr_(fr) { fr_->Lock(); }
+  ~FlagRegistryLock() { fr_->Unlock(); }
+ private:
+  FlagRegistry *const fr_;
+};
+
+#if defined(HAVE_PTHREAD)
+// The pthread.h header is available.  The pthreads library may or may not be
+// linked in with -lpthread.  If that library is not linked in, then it is
+// assumed that all operations involving command-line flags will be
+// single-threaded.
+
+#define SAFE_PTHREAD(fncall)  do { if ((fncall) != 0) abort(); } while (0)
+
+inline FlagRegistry::FlagRegistry() {
+  SAFE_PTHREAD(pthread_mutex_init(&lock_, NULL));
+}
+inline FlagRegistry::~FlagRegistry() {
+  SAFE_PTHREAD(pthread_mutex_destroy(&lock_));
+}
+
+inline void FlagRegistry::Lock() {
+  SAFE_PTHREAD(pthread_mutex_lock(&lock_));
+}
+inline void FlagRegistry::Unlock() {
+  SAFE_PTHREAD(pthread_mutex_unlock(&lock_));
+}
+
+// We want to use pthread_once here, for safety, but have to worry about
+// whether libpthread is linked in or not.  We declare a weak version of
+// the function, so we'll always compile (if the weak version is the only
+// one that ends up existing, then pthread_once will be equal to NULL).
+#ifdef HAVE___ATTRIBUTE__
+  // __THROW is defined in glibc systems.  It means, counter-intuitively,
+  // "This function will never throw an exception."  It's an optional
+  // optimization tool, but we may need to use it to match glibc prototypes.
+# ifndef __THROW     // I guess we're not on a glibc system
+#   define __THROW   // __THROW is just an optimization, so ok to make it ""
+# endif
+extern "C" int pthread_once(pthread_once_t *, void (*)(void))
+    __THROW __attribute__((weak));
+#endif
+
+FlagRegistry* FlagRegistry::GlobalRegistry() {
+  if (pthread_once) {   // means we're linked with -lpthread
+    static pthread_once_t global_registry_once = PTHREAD_ONCE_INIT;
+    pthread_once(&global_registry_once, &InitGlobalRegistry);
+  } else {
+    // Assume single-threaded execution.
+    InitGlobalRegistry();
+  }
+  return global_registry_;
+}
+
+#elif defined(HAVE_INITIALIZECRITICALSECTION)
+// The Windows version of the thread-safe code uses EnterCriticalSection and
+// LeaveCriticalSection to serialize access to the registry.
+
+#ifndef HAVE_INTERLOCKEDCOMPAREEXCHANGE
+// InitializeCriticalSection is available, but InterlockedCompareExchange
+// is not.  On a Windows system both should be available, and on Unix, neither
+// one should be available.
+#error "Please check settings for HAVE_INTERLOCKED... and HAVE_INITIALIZE..."
+#endif  // !HAVE_INTERLOCKEDCOMPAREEXCHANGE
+
+inline FlagRegistry::FlagRegistry() { InitializeCriticalSection(&lock_); }
+inline FlagRegistry::~FlagRegistry() { DeleteCriticalSection(&lock_); }
+
+inline void FlagRegistry::Lock() { EnterCriticalSection(&lock_); }
+inline void FlagRegistry::Unlock() { LeaveCriticalSection(&lock_); }
+
+FlagRegistry* FlagRegistry::GlobalRegistry() {
+  InitGlobalRegistry();
+  return global_registry_;
+}
+#endif  // !HAVE_PTHREAD && HAVE_INITIALIZECRITICALSECTION
+
+// Get the singleton FlagRegistry object
+FlagRegistry* FlagRegistry::global_registry_ = NULL;
+
+void FlagRegistry::InitGlobalRegistry() {
+  if (!global_registry_) {
+#ifdef HAVE_INTERLOCKEDCOMPAREEXCHANGE
+    FlagRegistry* new_global_registry = new FlagRegistry;
+    if (InterlockedCompareExchangePointer(
+            reinterpret_cast<void* volatile *>(&global_registry_),
+            new_global_registry,
+            NULL) != NULL) {
+      // Some other thread initialized global_registry_ first.
+      delete new_global_registry;
+    }
+#else  // !HAVE_INTERLOCKEDCOMPAREEXCHANGE
+    // Assume single-threaded execution, or else that this function call was
+    // serialized using pthread_once.
+    global_registry_ = new FlagRegistry;
+#endif  // HAVE_INTERLOCKEDCOMPAREEXCHANGE
+  }
+}
+
+void FlagRegistry::RegisterFlag(CommandLineFlag* flag) {
+  Lock();
+  pair<FlagIterator, bool> ins =
+    flags_.insert(pair<const char*, CommandLineFlag*>(flag->name(), flag));
+  if (ins.second == false) {   // means the name was already in the map
+    if (strcmp(ins.first->second->filename(), flag->filename()) != 0) {
+      fprintf(stderr,
+              "ERROR: flag '%s' was defined more than once "
+              "(in files '%s' and '%s').\n",
+              flag->name(),
+              ins.first->second->filename(),
+              flag->filename());
+    } else {
+      fprintf(stderr,
+              "ERROR: something wrong with flag '%s' in file '%s'.  "
+              "One possibility: file '%s' is being linked both statically "
+              "and dynamically into this executable.\n",
+              flag->name(),
+              flag->filename(), flag->filename());
+    }
+    commandlineflags_exitfunc(1);   // almost certainly exit()
+  }
+  // Also add to the flags_by_ptr_ map.
+  flags_by_ptr_[flag->current_->value_buffer_] = flag;
+  Unlock();
+}
+
+CommandLineFlag* FlagRegistry::FindFlagLocked(const char* name) {
+  FlagConstIterator i = flags_.find(name);
+  if (i == flags_.end()) {
+    return NULL;
+  } else {
+    return i->second;
+  }
+}
+
+CommandLineFlag* FlagRegistry::FindFlagViaPtrLocked(const void* flag_ptr) {
+  FlagPtrMap::const_iterator i = flags_by_ptr_.find(flag_ptr);
+  if (i == flags_by_ptr_.end()) {
+    return NULL;
+  } else {
+    return i->second;
+  }
+}
+
+CommandLineFlag* FlagRegistry::SplitArgumentLocked(const char* arg,
+                                                   string* key,
+                                                   const char** v,
+                                                   string* error_message) {
+  // Find the flag object for this option
+  const char* flag_name;
+  const char* value = strchr(arg, '=');
+  if (value == NULL) {
+    key->assign(arg);
+    *v = NULL;
+  } else {
+    // Strip out the "=value" portion from arg
+    key->assign(arg, value-arg);
+    *v = ++value;    // advance past the '='
+  }
+  flag_name = key->c_str();
+
+  CommandLineFlag* flag = FindFlagLocked(flag_name);
+
+  if (flag == NULL) {
+    // If we can't find the flag-name, then we should return an error.
+    // The one exception is if 1) the flag-name is 'nox', 2) there
+    // exists a flag named 'x', and 3) 'x' is a boolean flag.
+    // In that case, we want to return flag 'x'.
+    if (!(flag_name[0] == 'n' && flag_name[1] == 'o')) {
+      // flag-name is not 'nox', so we're not in the exception case.
+      *error_message = (string(kError) +
+                        "unknown command line flag '" + *key + "'\n");
+      return NULL;
+    }
+    flag = FindFlagLocked(flag_name+2);
+    if (flag == NULL) {
+      // No flag named 'x' exists, so we're not in the exception case.
+      *error_message = (string(kError) +
+                        "unknown command line flag '" + *key + "'\n");
+      return NULL;
+    }
+    if (strcmp(flag->type_name(), "bool") != 0) {
+      // 'x' exists but is not boolean, so we're not in the exception case.
+      *error_message = (string(kError) +
+                        "boolean value (" + *key + ") specified for " +
+                        flag->type_name() + " command line flag\n");
+      return NULL;
+    }
+    // We're in the exception case!
+    // Make up a fake value to replace the "no" we stripped out
+    key->assign(flag_name+2);   // the name without the "no"
+    *v = "0";
+  }
+
+  // Assign a value if this is a boolean flag
+  if (*v == NULL && strcmp(flag->type_name(), "bool") == 0) {
+    *v = "1";    // the --nox case was already handled, so this is the --x case
+  }
+
+  return flag;
+}
+
+bool TryParseLocked(const CommandLineFlag* flag, FlagValue* flag_value,
+                    const char* value, string* msg) {
+  // Use tenative_value, not flag_value, until we know value is valid.
+  FlagValue* tentative_value = flag_value->New();
+  if (!tentative_value->ParseFrom(value)) {
+    if (msg) {
+      *msg += (string(kError) + "illegal value '" + value +
+               + "' specified for " + flag->type_name() + " flag '"
+               + flag->name() + "'\n");
+    }
+    delete tentative_value;
+    return false;
+  } else if (!flag->Validate(*tentative_value)) {
+    if (msg) {
+      *msg += (string(kError) + "failed validation of new value "
+               + "'" + tentative_value->ToString() + "' for flag '" +
+               + flag->name() + "'\n");
+    }
+    delete tentative_value;
+    return false;
+  } else {
+    flag_value->CopyFrom(*tentative_value);
+    if (msg) {
+      *msg += (string(flag->name()) + " set to " + flag_value->ToString()
+               + "\n");
+    }
+    delete tentative_value;
+    return true;
+  }
+}
+
+bool FlagRegistry::SetFlagLocked(CommandLineFlag* flag,
+                                 const char* value,
+                                 FlagSettingMode set_mode,
+                                 string* msg) {
+  flag->UpdateModifiedBit();
+  switch (set_mode) {
+    case SET_FLAGS_VALUE: {
+      // set or modify the flag's value
+      if (!TryParseLocked(flag, flag->current_, value, msg))
+        return false;
+      flag->modified_ = true;
+      break;
+    }
+    case SET_FLAG_IF_DEFAULT: {
+      // set the flag's value, but only if it hasn't been set by someone else
+      if (!flag->modified_) {
+        if (!TryParseLocked(flag, flag->current_, value, msg))
+          return false;
+        flag->modified_ = true;
+      } else {
+        *msg = string(flag->name()) + " set to " + flag->current_value();
+      }
+      break;
+    }
+    case SET_FLAGS_DEFAULT: {
+      // modify the flag's default-value
+      if (!TryParseLocked(flag, flag->defvalue_, value, msg))
+        return false;
+      if (!flag->modified_) {
+        // Need to set both defvalue *and* current, in this case
+        TryParseLocked(flag, flag->current_, value, NULL);
+      }
+      break;
+    }
+    default: {
+      // unknown set_mode
+      assert(false);
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// --------------------------------------------------------------------
+// CommandLineFlagParser
+//    Parsing is done in two stages.  In the first, we go through
+//    argv.  For every flag-like arg we can make sense of, we parse
+//    it and set the appropriate FLAGS_* variable.  For every flag-
+//    like arg we can't make sense of, we store it in a vector,
+//    along with an explanation of the trouble.  In stage 2, we
+//    handle the 'reporting' flags like --help and --mpm_version.
+//    (This is via a call to HandleCommandLineHelpFlags(), in
+//    gflags_reporting.cc.)
+//    An optional stage 3 prints out the error messages.
+//       This is a bit of a simplification.  For instance, --flagfile
+//    is handled as soon as it's seen in stage 1, not in stage 2.
+// --------------------------------------------------------------------
+
+class CommandLineFlagParser {
+ public:
+  // The argument is the flag-registry to register the parsed flags in
+  explicit CommandLineFlagParser(FlagRegistry* reg) : registry_(reg) {}
+  ~CommandLineFlagParser() {}
+
+  // Stage 1: Every time this is called, it reads all flags in argv.
+  // However, it ignores all flags that have been successfully set
+  // before.  Typically this is only called once, so this 'reparsing'
+  // behavior isn't important.  It can be useful when trying to
+  // reparse after loading a dll, though.
+  uint32 ParseNewCommandLineFlags(int* argc, char*** argv, bool remove_flags);
+
+  // Stage 2: print reporting info and exit, if requested.
+  // In gflags_reporting.cc:HandleCommandLineHelpFlags().
+
+  // Stage 3: validate all the commandline flags that have validators
+  // registered.
+  void ValidateAllFlags();
+
+  // Stage 4: report any errors and return true if any were found.
+  bool ReportErrors();
+
+  // Set a particular command line option.  "newval" is a string
+  // describing the new value that the option has been set to.  If
+  // option_name does not specify a valid option name, or value is not
+  // a valid value for option_name, newval is empty.  Does recursive
+  // processing for --flagfile and --fromenv.  Returns the new value
+  // if everything went ok, or empty-string if not.  (Actually, the
+  // return-string could hold many flag/value pairs due to --flagfile.)
+  // NB: Must have called registry_->Lock() before calling this function.
+  string ProcessSingleOptionLocked(CommandLineFlag* flag,
+                                   const char* value,
+                                   FlagSettingMode set_mode);
+
+  // Set a whole batch of command line options as specified by contentdata,
+  // which is in flagfile format (and probably has been read from a flagfile).
+  // Returns the new value if everything went ok, or empty-string if
+  // not.  (Actually, the return-string could hold many flag/value
+  // pairs due to --flagfile.)
+  // NB: Must have called registry_->Lock() before calling this function.
+  string ProcessOptionsFromStringLocked(const string& contentdata,
+                                        FlagSettingMode set_mode);
+
+  // These are the 'recursive' flags, defined at the top of this file.
+  // Whenever we see these flags on the commandline, we must take action.
+  // These are called by ProcessSingleOptionLocked and, similarly, return
+  // new values if everything went ok, or the empty-string if not.
+  string ProcessFlagfileLocked(const string& flagval, FlagSettingMode set_mode);
+  // diff fromenv/tryfromenv
+  string ProcessFromenvLocked(const string& flagval, FlagSettingMode set_mode,
+                              bool errors_are_fatal);
+
+ private:
+  FlagRegistry* const registry_;
+  map<string, string> error_flags_;      // map from name to error message
+  // This could be a set<string>, but we reuse the map to minimize the .o size
+  map<string, string> undefined_names_;  // --[flag] name was not registered
+};
+
+
+// Parse a list of (comma-separated) flags.
+static void ParseFlagList(const char* value, vector<string>* flags) {
+  for (const char *p = value; p && *p; value = p) {
+    p = strchr(value, ',');
+    int len;
+    if (p) {
+      len = static_cast<int>(p - value);
+      p++;
+    } else {
+      len = static_cast<int>(strlen(value));
+    }
+
+    if (len == 0) {
+      fprintf(stderr, "ERROR: empty flaglist entry\n");
+      commandlineflags_exitfunc(1);   // almost certainly exit()
+    }
+    if (value[0] == '-') {
+      fprintf(stderr, "ERROR: flag \"%*s\" begins with '-'\n", len, value);
+      commandlineflags_exitfunc(1);
+    }
+
+    flags->push_back(string(value, len));
+  }
+}
+
+// Snarf an entire file into a C++ string.  This is just so that we
+// can do all the I/O in one place and not worry about it everywhere.
+// Plus, it's convenient to have the whole file contents at hand.
+// Adds a newline at the end of the file.
+#define PFATAL(s)  do { perror(s); commandlineflags_exitfunc(1); } while (0)
+
+static string ReadFileIntoString(const char* filename) {
+  const int kBufSize = 8092;
+  char buffer[kBufSize];
+  string s;
+  FILE* fp = fopen(filename, "r");
+  if (!fp)  PFATAL(filename);
+  size_t n;
+  while ( (n=fread(buffer, 1, kBufSize, fp)) > 0 ) {
+    if (ferror(fp))  PFATAL(filename);
+    s.append(buffer, n);
+  }
+  fclose(fp);
+  return s;
+}
+
+uint32 CommandLineFlagParser::ParseNewCommandLineFlags(int* argc, char*** argv,
+                                                       bool remove_flags) {
+  const char *program_name = strrchr((*argv)[0], PATH_SEPARATOR);   // nix path
+  program_name = (program_name == NULL ? (*argv)[0] : program_name+1);
+
+  int first_nonopt = *argc;        // for non-options moved to the end
+
+  registry_->Lock();
+  for (int i = 1; i < first_nonopt; i++) {
+    char* arg = (*argv)[i];
+
+    // Like getopt(), we permute non-option flags to be at the end.
+    if (arg[0] != '-' ||           // must be a program argument
+        (arg[0] == '-' && arg[1] == '\0')) {  // "-" is an argument, not a flag
+      memmove((*argv) + i, (*argv) + i+1, (*argc - (i+1)) * sizeof((*argv)[i]));
+      (*argv)[*argc-1] = arg;      // we go last
+      first_nonopt--;              // we've been pushed onto the stack
+      i--;                         // to undo the i++ in the loop
+      continue;
+    }
+
+    if (arg[0] == '-') arg++;      // allow leading '-'
+    if (arg[0] == '-') arg++;      // or leading '--'
+
+    // -- alone means what it does for GNU: stop options parsing
+    if (*arg == '\0') {
+      first_nonopt = i+1;
+      break;
+    }
+
+    // Find the flag object for this option
+    string key;
+    const char* value;
+    string error_message;
+    CommandLineFlag* flag = registry_->SplitArgumentLocked(arg, &key, &value,
+                                                           &error_message);
+    if (flag == NULL) {
+      undefined_names_[key] = "";    // value isn't actually used
+      error_flags_[key] = error_message;
+      continue;
+    }
+
+    if (value == NULL) {
+      // Boolean options are always assigned a value by SplitArgumentLocked()
+      assert(strcmp(flag->type_name(), "bool") != 0);
+      if (i+1 >= first_nonopt) {
+        // This flag needs a value, but there is nothing available
+        error_flags_[key] = (string(kError) + "flag '" + (*argv)[i] + "'"
+                             + " is missing its argument");
+        if (flag->help() && flag->help()[0] > '\001') {
+          // Be useful in case we have a non-stripped description.
+          error_flags_[key] += string("; flag description: ") + flag->help();
+        }
+        error_flags_[key] += "\n";
+        break;    // we treat this as an unrecoverable error
+      } else {
+        value = (*argv)[++i];                   // read next arg for value
+      }
+    }
+
+    // TODO(csilvers): only set a flag if we hadn't set it before here
+    ProcessSingleOptionLocked(flag, value, SET_FLAGS_VALUE);
+  }
+  registry_->Unlock();
+
+  if (remove_flags) {   // Fix up argc and argv by removing command line flags
+    (*argv)[first_nonopt-1] = (*argv)[0];
+    (*argv) += (first_nonopt-1);
+    (*argc) -= (first_nonopt-1);
+    first_nonopt = 1;   // because we still don't count argv[0]
+  }
+
+  logging_is_probably_set_up = true;   // because we've parsed --logdir, etc.
+
+  return first_nonopt;
+}
+
+string CommandLineFlagParser::ProcessFlagfileLocked(const string& flagval,
+                                                    FlagSettingMode set_mode) {
+  if (flagval.empty())
+    return "";
+
+  string msg;
+  vector<string> filename_list;
+  ParseFlagList(flagval.c_str(), &filename_list);  // take a list of filenames
+  for (size_t i = 0; i < filename_list.size(); ++i) {
+    const char* file = filename_list[i].c_str();
+    msg += ProcessOptionsFromStringLocked(ReadFileIntoString(file), set_mode);
+  }
+  return msg;
+}
+
+string CommandLineFlagParser::ProcessFromenvLocked(const string& flagval,
+                                                   FlagSettingMode set_mode,
+                                                   bool errors_are_fatal) {
+  if (flagval.empty())
+    return "";
+
+  string msg;
+  vector<string> flaglist;
+  ParseFlagList(flagval.c_str(), &flaglist);
+
+  for (size_t i = 0; i < flaglist.size(); ++i) {
+    const char* flagname = flaglist[i].c_str();
+    CommandLineFlag* flag = registry_->FindFlagLocked(flagname);
+    if (flag == NULL) {
+      error_flags_[flagname] = (string(kError) + "unknown command line flag"
+                                + " '" + flagname + "'"
+                                + " (via --fromenv or --tryfromenv)\n");
+      undefined_names_[flagname] = "";
+      continue;
+    }
+
+    const string envname = string("FLAGS_") + string(flagname);
+    const char* envval = getenv(envname.c_str());
+    if (!envval) {
+      if (errors_are_fatal) {
+        error_flags_[flagname] = (string(kError) + envname +
+                                  " not found in environment\n");
+      }
+      continue;
+    }
+
+    // Avoid infinite recursion.
+    if ((strcmp(envval, "fromenv") == 0) ||
+        (strcmp(envval, "tryfromenv") == 0)) {
+      error_flags_[flagname] = (string(kError) + "infinite recursion on " +
+                                "environment flag '" + envval + "'\n");
+      continue;
+    }
+
+    msg += ProcessSingleOptionLocked(flag, envval, set_mode);
+  }
+  return msg;
+}
+
+string CommandLineFlagParser::ProcessSingleOptionLocked(
+    CommandLineFlag* flag, const char* value, FlagSettingMode set_mode) {
+  string msg;
+  if (value && !registry_->SetFlagLocked(flag, value, set_mode, &msg)) {
+    error_flags_[flag->name()] = msg;
+    return "";
+  }
+
+  // The recursive flags, --flagfile and --fromenv and --tryfromenv,
+  // must be dealt with as soon as they're seen.  They will emit
+  // messages of their own.
+  if (strcmp(flag->name(), "flagfile") == 0) {
+    msg += ProcessFlagfileLocked(FLAGS_flagfile, set_mode);
+
+  } else if (strcmp(flag->name(), "fromenv") == 0) {
+    // last arg indicates envval-not-found is fatal (unlike in --tryfromenv)
+    msg += ProcessFromenvLocked(FLAGS_fromenv, set_mode, true);
+
+  } else if (strcmp(flag->name(), "tryfromenv") == 0) {
+    msg += ProcessFromenvLocked(FLAGS_tryfromenv, set_mode, false);
+  }
+
+  return msg;
+}
+
+void CommandLineFlagParser::ValidateAllFlags() {
+  FlagRegistryLock frl(registry_);
+  for (FlagRegistry::FlagConstIterator i = registry_->flags_.begin();
+       i != registry_->flags_.end(); ++i) {
+    if (!i->second->ValidateCurrent()) {
+      // only set a message if one isn't already there.  (If there's
+      // an error message, our job is done, even if it's not exactly
+      // the same error.)
+      if (error_flags_[i->second->name()].empty())
+        error_flags_[i->second->name()] = (string(kError) +
+                                           "--" + i->second->name() +
+                                           " must be set on the commandline" +
+                                           " (default value fails validation)");
+    }
+  }
+}
+
+bool CommandLineFlagParser::ReportErrors() {
+  // error_flags_ indicates errors we saw while parsing.
+  // But we ignore undefined-names if ok'ed by --undef_ok
+  if (!FLAGS_undefok.empty()) {
+    vector<string> flaglist;
+    ParseFlagList(FLAGS_undefok.c_str(), &flaglist);
+    for (size_t i = 0; i < flaglist.size(); ++i)
+      if (undefined_names_.find(flaglist[i]) != undefined_names_.end()) {
+        error_flags_[flaglist[i]] = "";    // clear the error message
+      }
+  }
+  // Likewise, if they decided to allow reparsing, all undefined-names
+  // are ok; we just silently ignore them now, and hope that a future
+  // parse will pick them up somehow.
+  if (allow_command_line_reparsing) {
+    for (map<string, string>::const_iterator it = undefined_names_.begin();
+         it != undefined_names_.end();  ++it)
+      error_flags_[it->first] = "";      // clear the error message
+  }
+
+  bool found_error = false;
+  for (map<string, string>::const_iterator it = error_flags_.begin();
+       it != error_flags_.end(); ++it) {
+    if (!it->second.empty()) {
+      fprintf(stderr, "%s", it->second.c_str());
+      found_error = true;
+    }
+  }
+  return found_error;
+}
+
+string CommandLineFlagParser::ProcessOptionsFromStringLocked(
+    const string& contentdata, FlagSettingMode set_mode) {
+  string retval;
+  const char* flagfile_contents = contentdata.c_str();
+  bool flags_are_relevant = true;   // set to false when filenames don't match
+  bool in_filename_section = false;
+
+  const char* line_end = flagfile_contents;
+  // We read this file a line at a time.
+  for (; line_end; flagfile_contents = line_end + 1) {
+    while (*flagfile_contents && isspace(*flagfile_contents))
+      ++flagfile_contents;
+    line_end = strchr(flagfile_contents, '\n');
+    size_t len = line_end ? static_cast<size_t>(line_end - flagfile_contents)
+                          : strlen(flagfile_contents);
+    string line(flagfile_contents, len);
+
+    // Each line can be one of four things:
+    // 1) A comment line -- we skip it
+    // 2) An empty line -- we skip it
+    // 3) A list of filenames -- starts a new filenames+flags section
+    // 4) A --flag=value line -- apply if previous filenames match
+    if (line.empty() || line[0] == '#') {
+      // comment or empty line; just ignore
+
+    } else if (line[0] == '-') {    // flag
+      in_filename_section = false;  // instead, it was a flag-line
+      if (!flags_are_relevant)      // skip this flag; applies to someone else
+        continue;
+
+      const char* name_and_val = line.c_str() + 1;    // skip the leading -
+      if (*name_and_val == '-')
+        name_and_val++;                               // skip second - too
+      string key;
+      const char* value;
+      string error_message;
+      CommandLineFlag* flag = registry_->SplitArgumentLocked(name_and_val,
+                                                             &key, &value,
+                                                             &error_message);
+      // By API, errors parsing flagfile lines are silently ignored.
+      if (flag == NULL) {
+        // "WARNING: flagname '" + key + "' not found\n"
+      } else if (value == NULL) {
+        // "WARNING: flagname '" + key + "' missing a value\n"
+      } else {
+        retval += ProcessSingleOptionLocked(flag, value, set_mode);
+      }
+
+    } else {                        // a filename!
+      if (!in_filename_section) {   // start over: assume filenames don't match
+        in_filename_section = true;
+        flags_are_relevant = false;
+      }
+
+      // Split the line up at spaces into glob-patterns
+      const char* space = line.c_str();   // just has to be non-NULL
+      for (const char* word = line.c_str(); *space; word = space+1) {
+        if (flags_are_relevant)     // we can stop as soon as we match
+          break;
+        space = strchr(word, ' ');
+        if (space == NULL)
+          space = word + strlen(word);
+        const string glob(word, space - word);
+        // We try matching both against the full argv0 and basename(argv0)
+#ifdef HAVE_FNMATCH_H
+        if (fnmatch(glob.c_str(),
+                    ProgramInvocationName(),
+                    FNM_PATHNAME) == 0 ||
+            fnmatch(glob.c_str(),
+                    ProgramInvocationShortName(),
+                    FNM_PATHNAME) == 0) {
+#else  // !HAVE_FNMATCH_H
+        if ((glob == ProgramInvocationName()) ||
+            (glob == ProgramInvocationShortName())) {
+#endif  // HAVE_FNMATCH_H
+          flags_are_relevant = true;
+        }
+      }
+    }
+  }
+  return retval;
+}
+
+// --------------------------------------------------------------------
+// GetFromEnv()
+// AddFlagValidator()
+//    These are helper functions for routines like BoolFromEnv() and
+//    RegisterFlagValidator, defined below.  They're defined here so
+//    they can live in the unnamed namespace (which makes friendship
+//    declarations for these classes possible).
+// --------------------------------------------------------------------
+
+template<typename T>
+T GetFromEnv(const char *varname, const char* type, T dflt) {
+  const char* const valstr = getenv(varname);
+  if (!valstr)
+    return dflt;
+  FlagValue ifv(new T, type);
+  if (!ifv.ParseFrom(valstr)) {
+    fprintf(stderr, "ERROR: error parsing env variable '%s' with value '%s'\n",
+            varname, valstr);
+    commandlineflags_exitfunc(1);
+  }
+  return OTHER_VALUE_AS(ifv, T);
+}
+
+bool AddFlagValidator(const void* flag_ptr, ValidateFnProto validate_fn_proto) {
+  // We want a lock around this routine, in case two threads try to
+  // add a validator (hopefully the same one!) at once.  We could use
+  // our own thread, but we need to loook at the registry anyway, so
+  // we just steal that one.
+  FlagRegistry* const registry = FlagRegistry::GlobalRegistry();
+  FlagRegistryLock frl(registry);
+  // First, find the flag whose current-flag storage is 'flag'.
+  // This is the CommandLineFlag whose current_->value_buffer_ == flag
+  CommandLineFlag* flag = registry->FindFlagViaPtrLocked(flag_ptr);
+  if (!flag) {
+    // WARNING << "Ignoring RegisterValidateFunction() for flag pointer "
+    //         << flag_ptr << ": no flag found at that address";
+    return false;
+  } else if (validate_fn_proto == flag->validate_function()) {
+    return true;    // ok to register the same function over and over again
+  } else if (validate_fn_proto != NULL && flag->validate_function() != NULL) {
+    // WARNING << "Ignoring RegisterValidateFunction() for flag '"
+    //         << flag->name() << "': validate-fn already registered";
+    return false;
+  } else {
+    flag->validate_fn_proto_ = validate_fn_proto;
+    return true;
+  }
+}
+
+}  // end unnamed namespaces
+
+
+// Now define the functions that are exported via the .h file
+
+// --------------------------------------------------------------------
+// FlagRegisterer
+//    This class exists merely to have a global constructor (the
+//    kind that runs before main(), that goes an initializes each
+//    flag that's been declared.  Note that it's very important we
+//    don't have a destructor that deletes flag_, because that would
+//    cause us to delete current_storage/defvalue_storage as well,
+//    which can cause a crash if anything tries to access the flag
+//    values in a global destructor.
+// --------------------------------------------------------------------
+
+// TODO(csilvers): When we're ready to have this error be a fatal one,
+// change this to give a compilation error (via COMPILE_ASSERT(false)).
+bool FlagsTypeWarn(const char *name) {
+  cerr << "Flag " << name << " is of type bool, but its default"
+       << " value is not a boolean.  NOTE: This will soon be a"
+       << " compilations error!";
+  return false;
+}
+
+FlagRegisterer::FlagRegisterer(const char* name, const char* type,
+                               const char* help, const char* filename,
+                               void* current_storage, void* defvalue_storage) {
+  if (help == NULL)
+    help = "";
+  // FlagValue expects the type-name to not include any namespace
+  // components, so we get rid of those, if any.
+  if (strchr(type, ':'))
+    type = strrchr(type, ':') + 1;
+  FlagValue* current = new FlagValue(current_storage, type);
+  FlagValue* defvalue = new FlagValue(defvalue_storage, type);
+  // Importantly, flag_ will never be deleted, so storage is always good.
+  CommandLineFlag* flag = new CommandLineFlag(name, help, filename,
+                                              current, defvalue);
+  FlagRegistry::GlobalRegistry()->RegisterFlag(flag);   // default registry
+}
+
+// --------------------------------------------------------------------
+// GetAllFlags()
+//    The main way the FlagRegistry class exposes its data.  This
+//    returns, as strings, all the info about all the flags in
+//    the main registry, sorted first by filename they are defined
+//    in, and then by flagname.
+// --------------------------------------------------------------------
+
+struct FilenameFlagnameCmp {
+  bool operator()(const CommandLineFlagInfo& a,
+                  const CommandLineFlagInfo& b) const {
+    int cmp = strcmp(a.filename.c_str(), b.filename.c_str());
+    if (cmp == 0)
+      cmp = strcmp(a.name.c_str(), b.name.c_str());  // secondary sort key
+    return cmp < 0;
+  }
+};
+
+void GetAllFlags(vector<CommandLineFlagInfo>* OUTPUT) {
+  FlagRegistry* const registry = FlagRegistry::GlobalRegistry();
+  registry->Lock();
+  for (FlagRegistry::FlagConstIterator i = registry->flags_.begin();
+       i != registry->flags_.end(); ++i) {
+    CommandLineFlagInfo fi;
+    i->second->FillCommandLineFlagInfo(&fi);
+    OUTPUT->push_back(fi);
+  }
+  registry->Unlock();
+  // Now sort the flags, first by filename they occur in, then alphabetically
+  sort(OUTPUT->begin(), OUTPUT->end(), FilenameFlagnameCmp());
+}
+
+// --------------------------------------------------------------------
+// SetArgv()
+// GetArgvs()
+// GetArgv()
+// GetArgv0()
+// ProgramInvocationName()
+// ProgramInvocationShortName()
+// SetUsageMessage()
+// ProgramUsage()
+//    Functions to set and get argv.  Typically the setter is called
+//    by ParseCommandLineFlags.  Also can get the ProgramUsage string,
+//    set by SetUsageMessage.
+// --------------------------------------------------------------------
+
+// These values are not protected by a Mutex because they are normally
+// set only once during program startup.
+static const char* argv0 = "UNKNOWN";      // just the program name
+static const char* cmdline = "";           // the entire command-line
+static vector<string> argvs;
+static uint32 argv_sum = 0;
+static const char* program_usage = "Warning: SetUsageMessage() never called";
+static bool program_usage_set = false;
+
+void SetArgv(int argc, const char** argv) {
+  static bool called_set_argv = false;
+  if (called_set_argv)         // we already have an argv for you
+    return;
+
+  called_set_argv = true;
+
+  assert(argc > 0);            // every program has at least a progname
+  argv0 = strdup(argv[0]);     // small memory leak, but fn only called once
+  assert(argv0);
+
+  string cmdline_string = string("");        // easier than doing strcats
+  argvs.clear();
+  for (int i = 0; i < argc; i++) {
+    if (i != 0)
+      cmdline_string += " ";
+    cmdline_string += argv[i];
+    argvs.push_back(argv[i]);
+  }
+  cmdline = strdup(cmdline_string.c_str());  // another small memory leak
+  assert(cmdline);
+
+  // Compute a simple sum of all the chars in argv
+  argv_sum = 0;
+  for (const char* c = cmdline; *c; c++)
+    argv_sum += *c;
+}
+
+const vector<string>& GetArgvs() { return argvs; }
+const char* GetArgv()            { return cmdline; }
+const char* GetArgv0()           { return argv0; }
+uint32 GetArgvSum()              { return argv_sum; }
+const char* ProgramInvocationName() {             // like the GNU libc fn
+  return GetArgv0();
+}
+const char* ProgramInvocationShortName() {        // like the GNU libc fn
+  const char* slash = strrchr(argv0, '/');
+#ifdef OS_WINDOWS
+  if (!slash)  slash = strrchr(argv0, '\\');
+#endif
+  return slash ? slash + 1 : argv0;
+}
+
+void SetUsageMessage(const string& usage) {
+  if (program_usage_set) {
+    fprintf(stderr, "ERROR: SetUsageMessage() called more than once\n");
+    exit(1);
+  }
+
+  program_usage = strdup(usage.c_str());      // small memory leak
+  program_usage_set = true;
+}
+
+const char* ProgramUsage() {
+  return program_usage;
+}
+
+// --------------------------------------------------------------------
+// GetCommandLineOption()
+// GetCommandLineFlagInfo()
+// GetCommandLineFlagInfoOrDie()
+// SetCommandLineOption()
+// SetCommandLineOptionWithMode()
+//    The programmatic way to set a flag's value, using a string
+//    for its name rather than the variable itself (that is,
+//    SetCommandLineOption("foo", x) rather than FLAGS_foo = x).
+//    There's also a bit more flexibility here due to the various
+//    set-modes, but typically these are used when you only have
+//    that flag's name as a string, perhaps at runtime.
+//    All of these work on the default, global registry.
+//       For GetCommandLineOption, return false if no such flag
+//    is known, true otherwise.  We clear "value" if a suitable
+//    flag is found.
+// --------------------------------------------------------------------
+
+
+bool GetCommandLineOption(const char* name, string* value) {
+  if (NULL == name)
+    return false;
+  assert(value);
+
+  FlagRegistry* const registry = FlagRegistry::GlobalRegistry();
+  FlagRegistryLock frl(registry);
+  CommandLineFlag* flag = registry->FindFlagLocked(name);
+  if (flag == NULL) {
+    return false;
+  } else {
+    *value = flag->current_value();
+    return true;
+  }
+}
+
+bool GetCommandLineFlagInfo(const char* name, CommandLineFlagInfo* OUTPUT) {
+  if (NULL == name) return false;
+  FlagRegistry* const registry = FlagRegistry::GlobalRegistry();
+  FlagRegistryLock frl(registry);
+  CommandLineFlag* flag = registry->FindFlagLocked(name);
+  if (flag == NULL) {
+    return false;
+  } else {
+    assert(OUTPUT);
+    flag->FillCommandLineFlagInfo(OUTPUT);
+    return true;
+  }
+}
+
+CommandLineFlagInfo GetCommandLineFlagInfoOrDie(const char* name) {
+  CommandLineFlagInfo info;
+  if (!GetCommandLineFlagInfo(name, &info)) {
+    fprintf(stderr, "FATAL ERROR: flag name '%s' doesn't exit", name);
+    commandlineflags_exitfunc(1);    // almost certainly exit()
+  }
+  return info;
+}
+
+string SetCommandLineOptionWithMode(const char* name, const char* value,
+                                    FlagSettingMode set_mode) {
+  string result;
+  FlagRegistry* const registry = FlagRegistry::GlobalRegistry();
+  FlagRegistryLock frl(registry);
+  CommandLineFlag* flag = registry->FindFlagLocked(name);
+  if (flag) {
+    CommandLineFlagParser parser(registry);
+    result = parser.ProcessSingleOptionLocked(flag, value, set_mode);
+    if (!result.empty()) {   // in the error case, we've already logged
+      // You could consider logging this change, if you wanted to know it:
+      //fprintf(stderr, "%sFLAGS_%s\n",
+      //        (set_mode == SET_FLAGS_DEFAULT ? "default value of " : ""),
+      //        result);
+    }
+  }
+  // The API of this function is that we return empty string on error
+  return result;
+}
+
+string SetCommandLineOption(const char* name, const char* value) {
+  return SetCommandLineOptionWithMode(name, value, SET_FLAGS_VALUE);
+}
+
+// --------------------------------------------------------------------
+// FlagSaver
+// FlagSaverImpl
+//    This class stores the states of all flags at construct time,
+//    and restores all flags to that state at destruct time.
+//    Its major implementation challenge is that it never modifies
+//    pointers in the 'main' registry, so global FLAG_* vars always
+//    point to the right place.
+// --------------------------------------------------------------------
+
+class FlagSaverImpl {
+ public:
+  // Constructs an empty FlagSaverImpl object.
+  explicit FlagSaverImpl(FlagRegistry* main_registry)
+      : main_registry_(main_registry) { }
+  ~FlagSaverImpl() {
+    // reclaim memory from each of our CommandLineFlags
+    vector<CommandLineFlag*>::const_iterator it;
+    for (it = backup_registry_.begin(); it != backup_registry_.end(); ++it)
+      delete *it;
+  }
+
+  // Saves the flag states from the flag registry into this object.
+  // It's an error to call this more than once.
+  // Must be called when the registry mutex is not held.
+  void SaveFromRegistry() {
+    FlagRegistryLock frl(main_registry_);
+    assert(backup_registry_.empty());   // call only once!
+    for (FlagRegistry::FlagConstIterator it = main_registry_->flags_.begin();
+         it != main_registry_->flags_.end();
+         ++it) {
+      const CommandLineFlag* main = it->second;
+      // Sets up all the const variables in backup correctly
+      CommandLineFlag* backup = new CommandLineFlag(
+          main->name(), main->help(), main->filename(),
+          main->current_->New(), main->defvalue_->New());
+      // Sets up all the non-const variables in backup correctly
+      backup->CopyFrom(*main);
+      backup_registry_.push_back(backup);   // add it to a convenient list
+    }
+  }
+
+  // Restores the saved flag states into the flag registry.  We
+  // assume no flags were added or deleted from the registry since
+  // the SaveFromRegistry; if they were, that's trouble!  Must be
+  // called when the registry mutex is not held.
+  void RestoreToRegistry() {
+    FlagRegistryLock frl(main_registry_);
+    vector<CommandLineFlag*>::const_iterator it;
+    for (it = backup_registry_.begin(); it != backup_registry_.end(); ++it) {
+      CommandLineFlag* main = main_registry_->FindFlagLocked((*it)->name());
+      if (main != NULL) {       // if NULL, flag got deleted from registry(!)
+        main->CopyFrom(**it);
+      }
+    }
+  }
+
+ private:
+  FlagRegistry* const main_registry_;
+  vector<CommandLineFlag*> backup_registry_;
+
+  FlagSaverImpl(const FlagSaverImpl&);  // no copying!
+  void operator=(const FlagSaverImpl&);
+};
+
+FlagSaver::FlagSaver()
+    : impl_(new FlagSaverImpl(FlagRegistry::GlobalRegistry())) {
+  impl_->SaveFromRegistry();
+}
+
+FlagSaver::~FlagSaver() {
+  impl_->RestoreToRegistry();
+  delete impl_;
+}
+
+
+// --------------------------------------------------------------------
+// CommandlineFlagsIntoString()
+// ReadFlagsFromString()
+// AppendFlagsIntoFile()
+// ReadFromFlagsFile()
+//    These are mostly-deprecated routines that stick the
+//    commandline flags into a file/string and read them back
+//    out again.  I can see a use for CommandlineFlagsIntoString,
+//    for creating a flagfile, but the rest don't seem that useful
+//    -- some, I think, are a poor-man's attempt at FlagSaver --
+//    and are included only until we can delete them from callers.
+//    Note they don't save --flagfile flags (though they do save
+//    the result of having called the flagfile, of course).
+// --------------------------------------------------------------------
+
+static string TheseCommandlineFlagsIntoString(
+    const vector<CommandLineFlagInfo>& flags) {
+  vector<CommandLineFlagInfo>::const_iterator i;
+
+  size_t retval_space = 0;
+  for (i = flags.begin(); i != flags.end(); ++i) {
+    // An (over)estimate of how much space it will take to print this flag
+    retval_space += i->name.length() + i->current_value.length() + 5;
+  }
+
+  string retval;
+  retval.reserve(retval_space);
+  for (i = flags.begin(); i != flags.end(); ++i) {
+    retval += "--";
+    retval += i->name;
+    retval += "=";
+    retval += i->current_value;
+    retval += "\n";
+  }
+  return retval;
+}
+
+string CommandlineFlagsIntoString() {
+  vector<CommandLineFlagInfo> sorted_flags;
+  GetAllFlags(&sorted_flags);
+  return TheseCommandlineFlagsIntoString(sorted_flags);
+}
+
+bool ReadFlagsFromString(const string& flagfilecontents,
+                         const char* /*prog_name*/,  // TODO(csilvers): nix this
+                         bool errors_are_fatal) {
+  FlagRegistry* const registry = FlagRegistry::GlobalRegistry();
+  FlagSaverImpl saved_states(registry);
+  saved_states.SaveFromRegistry();
+
+  CommandLineFlagParser parser(registry);
+  registry->Lock();
+  parser.ProcessOptionsFromStringLocked(flagfilecontents, SET_FLAGS_VALUE);
+  registry->Unlock();
+  // Should we handle --help and such when reading flags from a string?  Sure.
+  HandleCommandLineHelpFlags();
+  if (parser.ReportErrors()) {
+    // Error.  Restore all global flags to their previous values.
+    if (errors_are_fatal)
+      commandlineflags_exitfunc(1);    // almost certainly exit()
+    saved_states.RestoreToRegistry();
+    return false;
+  }
+  return true;
+}
+
+// TODO(csilvers): nix prog_name in favor of ProgramInvocationShortName()
+bool AppendFlagsIntoFile(const string& filename, const char *prog_name) {
+  FILE *fp = fopen(filename.c_str(), "a");
+  if (!fp) {
+    return false;
+  }
+
+  if (prog_name)
+    fprintf(fp, "%s\n", prog_name);
+
+  vector<CommandLineFlagInfo> flags;
+  GetAllFlags(&flags);
+  // But we don't want --flagfile, which leads to weird recursion issues
+  vector<CommandLineFlagInfo>::iterator i;
+  for (i = flags.begin(); i != flags.end(); ++i) {
+    if (strcmp(i->name.c_str(), "flagfile") == 0) {
+      flags.erase(i);
+      break;
+    }
+  }
+  fprintf(fp, "%s", TheseCommandlineFlagsIntoString(flags).c_str());
+
+  fclose(fp);
+  return true;
+}
+
+bool ReadFromFlagsFile(const string& filename, const char* prog_name,
+                       bool errors_are_fatal) {
+  return ReadFlagsFromString(ReadFileIntoString(filename.c_str()),
+                             prog_name, errors_are_fatal);
+}
+
+
+// --------------------------------------------------------------------
+// BoolFromEnv()
+// Int32FromEnv()
+// Int64FromEnv()
+// Uint64FromEnv()
+// DoubleFromEnv()
+// StringFromEnv()
+//    Reads the value from the environment and returns it.
+//    We use an FlagValue to make the parsing easy.
+//    Example usage:
+//       DEFINE_bool(myflag, BoolFromEnv("MYFLAG_DEFAULT", false), "whatever");
+// --------------------------------------------------------------------
+
+bool BoolFromEnv(const char *v, bool dflt) {
+  return GetFromEnv(v, "bool", dflt);
+}
+int32 Int32FromEnv(const char *v, int32 dflt) {
+  return GetFromEnv(v, "int32", dflt);
+}
+int64 Int64FromEnv(const char *v, int64 dflt)    {
+  return GetFromEnv(v, "int64", dflt);
+}
+uint64 Uint64FromEnv(const char *v, uint64 dflt) {
+  return GetFromEnv(v, "uint64", dflt);
+}
+double DoubleFromEnv(const char *v, double dflt) {
+  return GetFromEnv(v, "double", dflt);
+}
+const char *StringFromEnv(const char *varname, const char *dflt) {
+  const char* const val = getenv(varname);
+  return val ? val : dflt;
+}
+
+
+// --------------------------------------------------------------------
+// RegisterFlagValidator()
+//    RegisterFlagValidator() is the function that clients use to
+//    'decorate' a flag with a validation function.  Once this is
+//    done, every time the flag is set (including when the flag
+//    is parsed from argv), the validator-function is called.
+//       These functions return true if the validator was added
+//    successfully, or false if not: the flag already has a validator,
+//    (only one allowed per flag), the 1st arg isn't a flag, etc.
+//       This function is not thread-safe.
+// --------------------------------------------------------------------
+
+bool RegisterFlagValidator(const bool* flag,
+                           bool (*validate_fn)(const char*, bool)) {
+  return AddFlagValidator(flag, reinterpret_cast<ValidateFnProto>(validate_fn));
+}
+bool RegisterFlagValidator(const int32* flag,
+                           bool (*validate_fn)(const char*, int32)) {
+  return AddFlagValidator(flag, reinterpret_cast<ValidateFnProto>(validate_fn));
+}
+bool RegisterFlagValidator(const int64* flag,
+                           bool (*validate_fn)(const char*, int64)) {
+  return AddFlagValidator(flag, reinterpret_cast<ValidateFnProto>(validate_fn));
+}
+bool RegisterFlagValidator(const uint64* flag,
+                           bool (*validate_fn)(const char*, uint64)) {
+  return AddFlagValidator(flag, reinterpret_cast<ValidateFnProto>(validate_fn));
+}
+bool RegisterFlagValidator(const double* flag,
+                           bool (*validate_fn)(const char*, double)) {
+  return AddFlagValidator(flag, reinterpret_cast<ValidateFnProto>(validate_fn));
+}
+bool RegisterFlagValidator(const string* flag,
+                           bool (*validate_fn)(const char*, const string&)) {
+  return AddFlagValidator(flag, reinterpret_cast<ValidateFnProto>(validate_fn));
+}
+
+
+// --------------------------------------------------------------------
+// ParseCommandLineFlags()
+// ParseCommandLineNonHelpFlags()
+// HandleCommandLineHelpFlags()
+//    This is the main function called from main(), to actually
+//    parse the commandline.  It modifies argc and argv as described
+//    at the top of gflags.h.  You can also divide this
+//    function into two parts, if you want to do work between
+//    the parsing of the flags and the printing of any help output.
+// --------------------------------------------------------------------
+
+static uint32 ParseCommandLineFlagsInternal(int* argc, char*** argv,
+                                            bool remove_flags, bool do_report) {
+  SetArgv(*argc, const_cast<const char**>(*argv));    // save it for later
+
+  FlagRegistry* const registry = FlagRegistry::GlobalRegistry();
+  CommandLineFlagParser parser(registry);
+
+  // When we parse the commandline flags, we'll handle --flagfile,
+  // --tryfromenv, etc. as we see them (since flag-evaluation order
+  // may be important).  But sometimes apps set FLAGS_tryfromenv/etc.
+  // manually before calling ParseCommandLineFlags.  We want to evaluate
+  // those too, as if they were the first flags on the commandline.
+  registry->Lock();
+  parser.ProcessFlagfileLocked(FLAGS_flagfile, SET_FLAGS_VALUE);
+  // Last arg here indicates whether flag-not-found is a fatal error or not
+  parser.ProcessFromenvLocked(FLAGS_fromenv, SET_FLAGS_VALUE, true);
+  parser.ProcessFromenvLocked(FLAGS_tryfromenv, SET_FLAGS_VALUE, false);
+  registry->Unlock();
+
+  // Now get the flags specified on the commandline
+  const int r = parser.ParseNewCommandLineFlags(argc, argv, remove_flags);
+
+  if (do_report)
+    HandleCommandLineHelpFlags();   // may cause us to exit on --help, etc.
+
+  // See if any of the unset flags fail their validation checks
+  parser.ValidateAllFlags();
+
+  if (parser.ReportErrors())        // may cause us to exit on illegal flags
+    commandlineflags_exitfunc(1);   // almost certainly exit()
+  return r;
+}
+
+uint32 ParseCommandLineFlags(int* argc, char*** argv, bool remove_flags) {
+  return ParseCommandLineFlagsInternal(argc, argv, remove_flags, true);
+}
+
+uint32 ParseCommandLineNonHelpFlags(int* argc, char*** argv,
+                                    bool remove_flags) {
+  return ParseCommandLineFlagsInternal(argc, argv, remove_flags, false);
+}
+
+// --------------------------------------------------------------------
+// AllowCommandLineReparsing()
+// ReparseCommandLineNonHelpFlags()
+//    This is most useful for shared libraries.  The idea is if
+//    a flag is defined in a shared library that is dlopen'ed
+//    sometime after main(), you can ParseCommandLineFlags before
+//    the dlopen, then ReparseCommandLineNonHelpFlags() after the
+//    dlopen, to get the new flags.  But you have to explicitly
+//    Allow() it; otherwise, you get the normal default behavior
+//    of unrecognized flags calling a fatal error.
+// TODO(csilvers): this isn't used.  Just delete it?
+// --------------------------------------------------------------------
+
+void AllowCommandLineReparsing() {
+  allow_command_line_reparsing = true;
+}
+
+uint32 ReparseCommandLineNonHelpFlags() {
+  // We make a copy of argc and argv to pass in
+  const vector<string>& argvs = GetArgvs();
+  int tmp_argc = static_cast<int>(argvs.size());
+  char** tmp_argv = new char* [tmp_argc + 1];
+  for (int i = 0; i < tmp_argc; ++i)
+    tmp_argv[i] = strdup(argvs[i].c_str());   // TODO(csilvers): don't dup
+
+  const int retval = ParseCommandLineNonHelpFlags(&tmp_argc, &tmp_argv, false);
+
+  for (int i = 0; i < tmp_argc; ++i)
+    free(tmp_argv[i]);
+  delete[] tmp_argv;
+
+  return retval;
+}
+
+}  // namespace google
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gflags_reporting.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gflags_reporting.cc
new file mode 100644
index 0000000..cf6de2e
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gflags_reporting.cc
@@ -0,0 +1,417 @@
+// Copyright (c) 2006, 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.
+
+// ---
+// Author: Ray Sidney
+// Revamped and reorganized by Craig Silverstein
+//
+// This file contains code for handling the 'reporting' flags.  These
+// are flags that, when present, cause the program to report some
+// information and then exit.  --help and --version are the canonical
+// reporting flags, but we also have flags like --helpxml, etc.
+//
+// There's only one function that's meant to be called externally:
+// HandleCommandLineHelpFlags().  (Well, actually, ShowUsageWithFlags(),
+// ShowUsageWithFlagsRestrict(), and DescribeOneFlag() can be called
+// externally too, but there's little need for it.)  These are all
+// declared in the main commandlineflags.h header file.
+//
+// HandleCommandLineHelpFlags() will check what 'reporting' flags have
+// been defined, if any -- the "help" part of the function name is a
+// bit misleading -- and do the relevant reporting.  It should be
+// called after all flag-values have been assigned, that is, after
+// parsing the command-line.
+
+#include "config.h"
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
+#include <string>
+#include <vector>
+#include "google/gflags.h"
+
+#ifndef PATH_SEPARATOR
+#define PATH_SEPARATOR  '/'
+#endif
+
+using std::string;
+using std::vector;
+
+// The 'reporting' flags.  They all call exit().
+DEFINE_bool(help, false,
+            "show help on all flags [tip: all flags can have two dashes]");
+DEFINE_bool(helpfull, false,
+            "show help on all flags -- same as -help");
+DEFINE_bool(helpshort, false,
+            "show help on only the main module for this program");
+DEFINE_string(helpon, "",
+              "show help on the modules named by this flag value");
+DEFINE_string(helpmatch, "",
+              "show help on modules whose name contains the specified substr");
+DEFINE_bool(helppackage, false,
+            "show help on all modules in the main package");
+DEFINE_bool(helpxml, false,
+            "produce an xml version of help");
+DEFINE_bool(version, false,
+            "show version and build info and exit");
+
+namespace google {
+
+// --------------------------------------------------------------------
+// DescribeOneFlag()
+// DescribeOneFlagInXML()
+//    Routines that pretty-print info about a flag.  These use
+//    a CommandLineFlagInfo, which is the way the commandlineflags
+//    API exposes static info about a flag.
+// --------------------------------------------------------------------
+
+static const int kLineLength = 80;
+
+static void AddString(const string& s,
+                      string* final_string, int* chars_in_line) {
+  const int slen = static_cast<int>(s.length());
+  if (*chars_in_line + 1 + slen >= kLineLength) {  // < 80 chars/line
+    *final_string += "\n      ";
+    *chars_in_line = 6;
+  } else {
+    *final_string += " ";
+    *chars_in_line += 1;
+  }
+  *final_string += s;
+  *chars_in_line += slen;
+}
+
+// Create a descriptive string for a flag.
+// Goes to some trouble to make pretty line breaks.
+string DescribeOneFlag(const CommandLineFlagInfo& flag) {
+  string main_part = (string("    -") + flag.name +
+                      " (" + flag.description + ')');
+  const char* c_string = main_part.c_str();
+  int chars_left = static_cast<int>(main_part.length());
+  string final_string = "";
+  int chars_in_line = 0;  // how many chars in current line so far?
+  while (1) {
+    assert(chars_left == strlen(c_string));  // Unless there's a \0 in there?
+    const char* newline = strchr(c_string, '\n');
+    if (newline == NULL && chars_in_line+chars_left < kLineLength) {
+      // The whole remainder of the string fits on this line
+      final_string += c_string;
+      chars_in_line += chars_left;
+      break;
+    }
+    if (newline != NULL && newline - c_string < kLineLength - chars_in_line) {
+      int n = static_cast<int>(newline - c_string);
+      final_string.append(c_string, n);
+      chars_left -= n + 1;
+      c_string += n + 1;
+    } else {
+      // Find the last whitespace on this 80-char line
+      int whitespace = kLineLength-chars_in_line-1;  // < 80 chars/line
+      while ( whitespace > 0 && !isspace(c_string[whitespace]) ) {
+        --whitespace;
+      }
+      if (whitespace <= 0) {
+        // Couldn't find any whitespace to make a line break.  Just dump the
+        // rest out!
+        final_string += c_string;
+        chars_in_line = kLineLength;  // next part gets its own line for sure!
+        break;
+      }
+      final_string += string(c_string, whitespace);
+      chars_in_line += whitespace;
+      while (isspace(c_string[whitespace]))  ++whitespace;
+      c_string += whitespace;
+      chars_left -= whitespace;
+    }
+    if (*c_string == '\0')
+      break;
+    final_string += "\n      ";
+    chars_in_line = 6;
+  }
+
+  // Append data type
+  AddString(string("type: ") + flag.type, &final_string, &chars_in_line);
+  // Append the effective default value (i.e., the value that the flag
+  // will have after the command line is parsed if the flag is not
+  // specified on the command line), which may be different from the
+  // stored default value. This would happen if the value of the flag
+  // was modified before the command line was parsed. (Unless the
+  // value was modified using SetCommandLineOptionWithMode() with mode
+  // SET_FLAGS_DEFAULT.)
+  // Note that we are assuming this code is being executed because a help
+  // request was just parsed from the command line, in which case the
+  // printed value is indeed the effective default, as long as no value
+  // for the flag was parsed from the command line before "--help".
+  if (strcmp(flag.type.c_str(), "string") == 0) {  // add quotes for strings
+    AddString(string("default: \"") + flag.current_value + string("\""),
+              &final_string, &chars_in_line);
+  } else {
+    AddString(string("default: ") + flag.current_value,
+              &final_string, &chars_in_line);
+  }
+
+  final_string += '\n';
+  return final_string;
+}
+
+// Simple routine to xml-escape a string: escape & and < only.
+static string XMLText(const string& txt) {
+  string ans = txt;
+  for (string::size_type pos = 0; (pos = ans.find("&", pos)) != string::npos; )
+    ans.replace(pos++, 1, "&amp;");
+  for (string::size_type pos = 0; (pos = ans.find("<", pos)) != string::npos; )
+    ans.replace(pos++, 1, "&lt;");
+  return ans;
+}
+
+static string DescribeOneFlagInXML(const CommandLineFlagInfo& flag) {
+  // The file and flagname could have been attributes, but default
+  // and meaning need to avoid attribute normalization.  This way it
+  // can be parsed by simple programs, in addition to xml parsers.
+  return (string("<flag>") +
+          "<file>" + XMLText(flag.filename) + "</file>" +
+          "<name>" + XMLText(flag.name) + "</name>" +
+          "<meaning>" + XMLText(flag.description) + "</meaning>" +
+          "<default>" + XMLText(flag.default_value) + "</default>" +
+          "<type>" + XMLText(flag.type) + "</type>" +
+          string("</flag>"));
+}
+
+// --------------------------------------------------------------------
+// ShowUsageWithFlags()
+// ShowUsageWithFlagsRestrict()
+// ShowXMLOfFlags()
+//    These routines variously expose the registry's list of flag
+//    values.  ShowUsage*() prints the flag-value information
+//    to stdout in a user-readable format (that's what --help uses).
+//    The Restrict() version limits what flags are shown.
+//    ShowXMLOfFlags() prints the flag-value information to stdout
+//    in a machine-readable format.  In all cases, the flags are
+//    sorted: first by filename they are defined in, then by flagname.
+// --------------------------------------------------------------------
+
+static const char* Basename(const char* filename) {
+  const char* sep = strrchr(filename, PATH_SEPARATOR);
+  return sep ? sep + 1 : filename;
+}
+
+static string Dirname(const string& filename) {
+  string::size_type sep = filename.rfind(PATH_SEPARATOR);
+  return filename.substr(0, (sep == string::npos) ? 0 : sep);
+}
+
+// Test whether a filename contains at least one of the substrings.
+static bool FileMatchesSubstring(const string& filename,
+                                 const vector<string>& substrings) {
+  for (vector<string>::const_iterator target = substrings.begin();
+       target != substrings.end();
+       ++target) {
+    if (strstr(filename.c_str(), target->c_str()) != NULL) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Show help for every filename which matches any of the target substrings.
+// If substrings is empty, shows help for every file. If a flag's help message
+// has been stripped (e.g. by adding '#define STRIP_FLAG_HELP 1' before
+// including google/gflags.h), then this flag will not be displayed by
+// '--help' and its variants.
+static void ShowUsageWithFlagsMatching(const char *argv0,
+                                       const vector<string> &substrings) {
+  fprintf(stdout, "%s: %s\n", Basename(argv0), ProgramUsage());
+
+  vector<CommandLineFlagInfo> flags;
+  GetAllFlags(&flags);           // flags are sorted by filename, then flagname
+
+  string last_filename = "";     // so we know when we're at a new file
+  bool first_directory = true;   // controls blank lines between dirs
+  bool found_match = false;      // stays false iff no dir matches restrict
+  for (vector<CommandLineFlagInfo>::const_iterator flag = flags.begin();
+       flag != flags.end();
+       ++flag) {
+    if (substrings.empty() ||
+        FileMatchesSubstring(flag->filename, substrings)) {
+      // If the flag has been stripped, pretend that it doesn't exist.
+      if (flag->description == kStrippedFlagHelp) continue;
+      found_match = true;     // this flag passed the match!
+      if (flag->filename != last_filename) {                      // new file
+        if (Dirname(flag->filename) != Dirname(last_filename)) {  // new dir!
+          if (!first_directory)
+            fprintf(stdout, "\n\n");   // put blank lines between directories
+          first_directory = false;
+        }
+        fprintf(stdout, "\n  Flags from %s:\n", flag->filename.c_str());
+        last_filename = flag->filename;
+      }
+      // Now print this flag
+      fprintf(stdout, "%s", DescribeOneFlag(*flag).c_str());
+    }
+  }
+  if (!found_match && !substrings.empty()) {
+    fprintf(stdout, "\n  No modules matched: use -help\n");
+  }
+}
+
+void ShowUsageWithFlagsRestrict(const char *argv0, const char *restrict) {
+  vector<string> substrings;
+  if (restrict != NULL && *restrict != '\0') {
+    substrings.push_back(restrict);
+  }
+  ShowUsageWithFlagsMatching(argv0, substrings);
+}
+
+void ShowUsageWithFlags(const char *argv0) {
+  ShowUsageWithFlagsRestrict(argv0, "");
+}
+
+// Convert the help, program, and usage to xml.
+static void ShowXMLOfFlags(const char *prog_name) {
+  vector<CommandLineFlagInfo> flags;
+  GetAllFlags(&flags);   // flags are sorted: by filename, then flagname
+
+  // XML.  There is no corresponding schema yet
+  fprintf(stdout, "<?xml version=\"1.0\"?>\n");
+  // The document
+  fprintf(stdout, "<AllFlags>\n");
+  // the program name and usage
+  fprintf(stdout, "<program>%s</program>\n",
+          XMLText(Basename(prog_name)).c_str());
+  fprintf(stdout, "<usage>%s</usage>\n",
+          XMLText(ProgramUsage()).c_str());
+  // All the flags
+  for (vector<CommandLineFlagInfo>::const_iterator flag = flags.begin();
+       flag != flags.end();
+       ++flag) {
+    if (flag->description != kStrippedFlagHelp)
+      fprintf(stdout, "%s\n", DescribeOneFlagInXML(*flag).c_str());
+  }
+  // The end of the document
+  fprintf(stdout, "</AllFlags>\n");
+}
+
+// --------------------------------------------------------------------
+// ShowVersion()
+//    Called upon --version.  Prints build-related info.
+// --------------------------------------------------------------------
+
+static void ShowVersion() {
+  fprintf(stdout, "%s\n", ProgramInvocationShortName());
+  // TODO: add other stuff, like a timestamp, who built it, what
+  //       target they built, etc.
+
+# if !defined(NDEBUG)
+  fprintf(stdout, "Debug build (NDEBUG not #defined)\n");
+# endif
+}
+
+// --------------------------------------------------------------------
+// HandleCommandLineHelpFlags()
+//    Checks all the 'reporting' commandline flags to see if any
+//    have been set.  If so, handles them appropriately.  Note
+//    that all of them, by definition, cause the program to exit
+//    if they trigger.
+// --------------------------------------------------------------------
+
+void HandleCommandLineHelpFlags() {
+  const char* progname = ProgramInvocationShortName();
+  extern void (*commandlineflags_exitfunc)(int);   // in gflags.cc
+
+  if (FLAGS_helpshort) {
+    // show only flags related to this binary:
+    // E.g. for fileutil.cc, want flags containing   ... "/fileutil." cc
+    vector<string> substrings;
+    substrings.push_back(string("/") + progname + ".");
+    substrings.push_back(string("/") + progname + "-main.");
+    substrings.push_back(string("/") + progname + "_main.");
+    ShowUsageWithFlagsMatching(progname, substrings);
+    commandlineflags_exitfunc(1);   // almost certainly exit()
+
+  } else if (FLAGS_help || FLAGS_helpfull) {
+    // show all options
+    ShowUsageWithFlagsRestrict(progname, "");   // empty restrict
+    commandlineflags_exitfunc(1);
+
+  } else if (!FLAGS_helpon.empty()) {
+    string restrict = "/" + FLAGS_helpon + ".";
+    ShowUsageWithFlagsRestrict(progname, restrict.c_str());
+    commandlineflags_exitfunc(1);
+
+  } else if (!FLAGS_helpmatch.empty()) {
+    ShowUsageWithFlagsRestrict(progname, FLAGS_helpmatch.c_str());
+    commandlineflags_exitfunc(1);
+
+  } else if (FLAGS_helppackage) {
+    // Shows help for all files in the same directory as main().  We
+    // don't want to resort to looking at dirname(progname), because
+    // the user can pick progname, and it may not relate to the file
+    // where main() resides.  So instead, we search the flags for a
+    // filename like "/progname.cc", and take the dirname of that.
+    vector<CommandLineFlagInfo> flags;
+    GetAllFlags(&flags);
+    vector<string> substrings;
+    substrings.push_back(string("/") + progname + ".");
+    substrings.push_back(string("/") + progname + "-main.");
+    substrings.push_back(string("/") + progname + "_main.");
+    string last_package = "";
+    for (vector<CommandLineFlagInfo>::const_iterator flag = flags.begin();
+         flag != flags.end();
+         ++flag) {
+      if (!FileMatchesSubstring(flag->filename, substrings))
+        continue;
+      const string package = Dirname(flag->filename) + "/";
+      if (package != last_package) {
+        ShowUsageWithFlagsRestrict(progname, package.c_str());
+        if (last_package != "") {      // means this isn't our first pkg
+          fprintf(stderr, "WARNING: Multiple packages contain a file=%s\n",
+                  progname);
+        }
+        last_package = package;
+      }
+    }
+    if (last_package == "") {   // never found a package to print
+      fprintf(stderr, "WARNING: Unable to find a package for file=%s\n",
+              progname);
+    }
+    commandlineflags_exitfunc(1);
+
+  } else if (FLAGS_helpxml) {
+    ShowXMLOfFlags(progname);
+    commandlineflags_exitfunc(1);
+
+  } else if (FLAGS_version) {
+    ShowVersion();
+    // Unlike help, we may be asking for version in a script, so return 0
+    commandlineflags_exitfunc(0);
+  }
+}
+
+}  // namespace google
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/google/gflags.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/google/gflags.h
new file mode 100644
index 0000000..3fef830
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/google/gflags.h
@@ -0,0 +1,519 @@
+// Copyright (c) 2006, 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.
+
+// ---
+// Author: Ray Sidney
+// Revamped and reorganized by Craig Silverstein
+//
+// This is the file that should be included by any file which declares
+// or defines a command line flag or wants to parse command line flags
+// or print a program usage message (which will include information about
+// flags).  Executive summary, in the form of an example foo.cc file:
+//
+//    #include "foo.h"         // foo.h has a line "DECLARE_int32(start);"
+//
+//    DEFINE_int32(end, 1000, "The last record to read");
+//    DECLARE_bool(verbose);   // some other file has a DEFINE_bool(verbose, ...)
+//
+//    void MyFunc() {
+//      if (FLAGS_verbose) printf("Records %d-%d\n", FLAGS_start, FLAGS_end);
+//    }
+//
+// Then, at the command-line:
+//    ./foo --noverbose --start=5 --end=100
+//
+// For more details, see
+//    doc/gflags.html
+//
+// --- A note about thread-safety:
+//
+// We describe many functions in this routine as being thread-hostile,
+// thread-compatible, or thread-safe.  Here are the meanings we use:
+//
+// thread-safe: it is safe for multiple threads to call this routine
+//   (or, when referring to a class, methods of this class)
+//   concurrently.
+// thread-hostile: it is not safe for multiple threads to call this
+//   routine (or methods of this class) concurrently.  In gflags,
+//   most thread-hostile routines are intended to be called early in,
+//   or even before, main() -- that is, before threads are spawned.
+// thread-compatible: it is safe for multiple threads to read from
+//   this variable (when applied to variables), or to call const
+//   methods of this class (when applied to classes), as long as no
+//   other thread is writing to the variable or calling non-const
+//   methods of this class.
+
+#ifndef GOOGLE_GFLAGS_H_
+#define GOOGLE_GFLAGS_H_
+
+#include "config.h"
+#include <string>
+#include <vector>
+
+// We care a lot about number of bits things take up.  Unfortunately,
+// systems define their bit-specific ints in a lot of different ways.
+// We use our own way, and have a typedef to get there.
+#if defined(HAVE_STDINT_H)
+#include <stdint.h>             // the normal place uint16_t is defined
+#elif defined(HAVE_SYSTYPES_H)
+#include <sys/types.h>          // the normal place u_int16_t is defined
+#elif defined(HAVE_INTTYPES_H)
+#include <inttypes.h>           // a third place for uint16_t or u_int16_t
+#endif
+
+namespace google {
+
+#if defined(HAVE_UINT16_T)  // the C99 format
+typedef int32_t int32;
+typedef uint32_t uint32;
+typedef int64_t int64;
+typedef uint64_t uint64;
+#elif defined(HAVE_U_INT16_T)  // the BSD format
+typedef int32_t int32;
+typedef u_int32_t uint32;
+typedef int64_t int64;
+typedef u_int64_t uint64;
+#elif defined(HAVE___INT16)  // the windows (vc++) format
+typedef __int32 int32;
+typedef unsigned __int32 uint32;
+typedef __int64 int64;
+typedef unsigned __int64 uint64;
+#else
+#error Do not know how to define a 32-bit integer quantity on your system
+#endif
+
+// --------------------------------------------------------------------
+// To actually define a flag in a file, use DEFINE_bool,
+// DEFINE_string, etc. at the bottom of this file.  You may also find
+// it useful to register a validator with the flag.  This ensures that
+// when the flag is parsed from the commandline, or is later set via
+// SetCommandLineOption, we call the validation function.  The
+// validation function should return true if the flag value is valid,
+// and false otherwise.
+//
+// This function is safe to call at global construct time (as in the
+// example below).
+//
+// Example use:
+//    static bool ValidatePort(const char* flagname, int32 value) {
+//       if (value > 0 && value < 32768)   // value is ok
+//         return true;
+//       printf("Invalid value for --%s: %d\n", flagname, (int)value);
+//       return false;
+//    }
+//    DEFINE_int32(port, 0, "What port to listen on");
+//    static bool dummy = RegisterFlagValidator(&FLAGS_port, &ValidatePort);
+
+// Returns true if successfully registered, false if not (because the
+// first argument doesn't point to a command-line flag, or because a
+// validator is already registered for this flag).
+bool RegisterFlagValidator(const bool* flag,
+                           bool (*validate_fn)(const char*, bool));
+bool RegisterFlagValidator(const int32* flag,
+                           bool (*validate_fn)(const char*, int32));
+bool RegisterFlagValidator(const int64* flag,
+                           bool (*validate_fn)(const char*, int64));
+bool RegisterFlagValidator(const uint64* flag,
+                           bool (*validate_fn)(const char*, uint64));
+bool RegisterFlagValidator(const double* flag,
+                           bool (*validate_fn)(const char*, double));
+bool RegisterFlagValidator(const std::string* flag,
+                           bool (*validate_fn)(const char*, const std::string&));
+
+
+// --------------------------------------------------------------------
+// These methods are the best way to get access to info about the
+// list of commandline flags.  Note that these routines are pretty slow.
+//   GetAllFlags: mostly-complete info about the list, sorted by file.
+//   ShowUsageWithFlags: pretty-prints the list to stdout (what --help does)
+//   ShowUsageWithFlagsRestrict: limit to filenames with restrict as a substr
+//
+// In addition to accessing flags, you can also access argv[0] (the program
+// name) and argv (the entire commandline), which we sock away a copy of.
+// These variables are static, so you should only set them once.
+
+struct CommandLineFlagInfo {
+  std::string name;           // the name of the flag
+  std::string type;           // the type of the flag: int32, etc
+  std::string description;    // the "help text" associated with the flag
+  std::string current_value;  // the current value, as a string
+  std::string default_value;  // the default value, as a string
+  std::string filename;       // 'cleaned' version of filename holding the flag
+  bool has_validator_fn;      // true if RegisterFlagValidator called on flag
+  bool is_default;            // true if the flag has default value
+};
+
+extern void GetAllFlags(std::vector<CommandLineFlagInfo>* OUTPUT);
+// These two are actually defined in commandlineflags_reporting.cc.
+extern void ShowUsageWithFlags(const char *argv0);  // what --help does
+extern void ShowUsageWithFlagsRestrict(const char *argv0, const char *restrict);
+
+// Create a descriptive string for a flag.
+// Goes to some trouble to make pretty line breaks.
+extern std::string DescribeOneFlag(const CommandLineFlagInfo& flag);
+
+// Thread-hostile; meant to be called before any threads are spawned.
+extern void SetArgv(int argc, const char** argv);
+// The following functions are thread-safe as long as SetArgv() is
+// only called before any threads start.
+extern const std::vector<std::string>& GetArgvs();  // all of argv as a vector
+extern const char* GetArgv();               // all of argv as a string
+extern const char* GetArgv0();              // only argv0
+extern uint32 GetArgvSum();                 // simple checksum of argv
+extern const char* ProgramInvocationName(); // argv0, or "UNKNOWN" if not set
+extern const char* ProgramInvocationShortName();   // basename(argv0)
+// ProgramUsage() is thread-safe as long as SetUsageMessage() is only
+// called before any threads start.
+extern const char* ProgramUsage();          // string set by SetUsageMessage()
+
+
+// --------------------------------------------------------------------
+// Normally you access commandline flags by just saying "if (FLAGS_foo)"
+// or whatever, and set them by calling "FLAGS_foo = bar" (or, more
+// commonly, via the DEFINE_foo macro).  But if you need a bit more
+// control, we have programmatic ways to get/set the flags as well.
+// These programmatic ways to access flags are thread-safe, but direct
+// access is only thread-compatible.
+
+// Return true iff the flagname was found.
+// OUTPUT is set to the flag's value, or unchanged if we return false.
+extern bool GetCommandLineOption(const char* name, std::string* OUTPUT);
+
+// Return true iff the flagname was found. OUTPUT is set to the flag's
+// CommandLineFlagInfo or unchanged if we return false.
+extern bool GetCommandLineFlagInfo(const char* name,
+                                   CommandLineFlagInfo* OUTPUT);
+
+// Return the CommandLineFlagInfo of the flagname.  exit() if name not found.
+// Example usage, to check if a flag's value is currently the default value:
+//   if (GetCommandLineFlagInfoOrDie("foo").is_default) ...
+extern CommandLineFlagInfo GetCommandLineFlagInfoOrDie(const char* name);
+
+enum FlagSettingMode {
+  // update the flag's value (can call this multiple times).
+  SET_FLAGS_VALUE,
+  // update the flag's value, but *only if* it has not yet been updated
+  // with SET_FLAGS_VALUE, SET_FLAG_IF_DEFAULT, or "FLAGS_xxx = nondef".
+  SET_FLAG_IF_DEFAULT,
+  // set the flag's default value to this.  If the flag has not yet updated
+  // yet (via SET_FLAGS_VALUE, SET_FLAG_IF_DEFAULT, or "FLAGS_xxx = nondef")
+  // change the flag's current value to the new default value as well.
+  SET_FLAGS_DEFAULT
+};
+
+// Set a particular flag ("command line option").  Returns a string
+// describing the new value that the option has been set to.  The
+// return value API is not well-specified, so basically just depend on
+// it to be empty if the setting failed for some reason -- the name is
+// not a valid flag name, or the value is not a valid value -- and
+// non-empty else.
+
+// SetCommandLineOption uses set_mode == SET_FLAGS_VALUE (the common case)
+extern std::string SetCommandLineOption(const char* name, const char* value);
+extern std::string SetCommandLineOptionWithMode(const char* name, const char* value,
+                                                FlagSettingMode set_mode);
+
+
+// --------------------------------------------------------------------
+// Saves the states (value, default value, whether the user has set
+// the flag, registered validators, etc) of all flags, and restores
+// them when the FlagSaver is destroyed.  This is very useful in
+// tests, say, when you want to let your tests change the flags, but
+// make sure that they get reverted to the original states when your
+// test is complete.
+//
+// Example usage:
+//   void TestFoo() {
+//     FlagSaver s1;
+//     FLAG_foo = false;
+//     FLAG_bar = "some value";
+//
+//     // test happens here.  You can return at any time
+//     // without worrying about restoring the FLAG values.
+//   }
+//
+// Note: This class is marked with __attribute__((unused)) because all the
+// work is done in the constructor and destructor, so in the standard
+// usage example above, the compiler would complain that it's an
+// unused variable.
+//
+// This class is thread-safe.
+
+class FlagSaver {
+ public:
+  FlagSaver();
+  ~FlagSaver();
+
+ private:
+  class FlagSaverImpl* impl_;   // we use pimpl here to keep API steady
+
+  FlagSaver(const FlagSaver&);  // no copying!
+  void operator=(const FlagSaver&);
+#if HAVE___ATTRIBUTE__
+} __attribute__ ((unused));
+#else  // !HAVE___ATTRIBUTE__
+};
+#endif  // HAVE___ATTRIBUTE__
+
+// --------------------------------------------------------------------
+// Some deprecated or hopefully-soon-to-be-deprecated functions.
+
+// This is often used for logging.  TODO(csilvers): figure out a better way
+extern std::string CommandlineFlagsIntoString();
+// Usually where this is used, a FlagSaver should be used instead.
+extern bool ReadFlagsFromString(const std::string& flagfilecontents,
+                                const char* prog_name,
+                                bool errors_are_fatal); // uses SET_FLAGS_VALUE
+
+// These let you manually implement --flagfile functionality.
+// DEPRECATED.
+extern bool AppendFlagsIntoFile(const std::string& filename, const char* prog_name);
+extern bool SaveCommandFlags();  // actually defined in google.cc !
+extern bool ReadFromFlagsFile(const std::string& filename, const char* prog_name,
+                              bool errors_are_fatal);   // uses SET_FLAGS_VALUE
+
+
+// --------------------------------------------------------------------
+// Useful routines for initializing flags from the environment.
+// In each case, if 'varname' does not exist in the environment
+// return defval.  If 'varname' does exist but is not valid
+// (e.g., not a number for an int32 flag), abort with an error.
+// Otherwise, return the value.  NOTE: for booleans, for true use
+// 't' or 'T' or 'true' or '1', for false 'f' or 'F' or 'false' or '0'.
+
+extern bool BoolFromEnv(const char *varname, bool defval);
+extern int32 Int32FromEnv(const char *varname, int32 defval);
+extern int64 Int64FromEnv(const char *varname, int64 defval);
+extern uint64 Uint64FromEnv(const char *varname, uint64 defval);
+extern double DoubleFromEnv(const char *varname, double defval);
+extern const char *StringFromEnv(const char *varname, const char *defval);
+
+
+// --------------------------------------------------------------------
+// The next two functions parse commandlineflags from main():
+
+// Set the "usage" message for this program.  For example:
+//   string usage("This program does nothing.  Sample usage:\n");
+//   usage += argv[0] + " <uselessarg1> <uselessarg2>";
+//   SetUsageMessage(usage);
+// Do not include commandline flags in the usage: we do that for you!
+// Thread-hostile; meant to be called before any threads are spawned.
+extern void SetUsageMessage(const std::string& usage);
+
+// Looks for flags in argv and parses them.  Rearranges argv to put
+// flags first, or removes them entirely if remove_flags is true.
+// If a flag is defined more than once in the command line or flag
+// file, the last definition is used.
+// See top-of-file for more details on this function.
+#ifndef SWIG   // In swig, use ParseCommandLineFlagsScript() instead.
+extern uint32 ParseCommandLineFlags(int *argc, char*** argv,
+                                    bool remove_flags);
+#endif
+
+
+// Calls to ParseCommandLineNonHelpFlags and then to
+// HandleCommandLineHelpFlags can be used instead of a call to
+// ParseCommandLineFlags during initialization, in order to allow for
+// changing default values for some FLAGS (via
+// e.g. SetCommandLineOptionWithMode calls) between the time of
+// command line parsing and the time of dumping help information for
+// the flags as a result of command line parsing.
+// If a flag is defined more than once in the command line or flag
+// file, the last definition is used.
+extern uint32 ParseCommandLineNonHelpFlags(int *argc, char*** argv,
+                                           bool remove_flags);
+// This is actually defined in commandlineflags_reporting.cc.
+// This function is misnamed (it also handles --version, etc.), but
+// it's too late to change that now. :-(
+extern void HandleCommandLineHelpFlags();   // in commandlineflags_reporting.cc
+
+// Allow command line reparsing.  Disables the error normally
+// generated when an unknown flag is found, since it may be found in a
+// later parse.  Thread-hostile; meant to be called before any threads
+// are spawned.
+extern void AllowCommandLineReparsing();
+
+// Reparse the flags that have not yet been recognized.
+// Only flags registered since the last parse will be recognized.
+// Any flag value must be provided as part of the argument using "=",
+// not as a separate command line argument that follows the flag argument.
+// Intended for handling flags from dynamically loaded libraries,
+// since their flags are not registered until they are loaded.
+extern uint32 ReparseCommandLineNonHelpFlags();
+
+
+// --------------------------------------------------------------------
+// Now come the command line flag declaration/definition macros that
+// will actually be used.  They're kind of hairy.  A major reason
+// for this is initialization: we want people to be able to access
+// variables in global constructors and have that not crash, even if
+// their global constructor runs before the global constructor here.
+// (Obviously, we can't guarantee the flags will have the correct
+// default value in that case, but at least accessing them is safe.)
+// The only way to do that is have flags point to a static buffer.
+// So we make one, using a union to ensure proper alignment, and
+// then use placement-new to actually set up the flag with the
+// correct default value.  In the same vein, we have to worry about
+// flag access in global destructors, so FlagRegisterer has to be
+// careful never to destroy the flag-values it constructs.
+//
+// Note that when we define a flag variable FLAGS_<name>, we also
+// preemptively define a junk variable, FLAGS_no<name>.  This is to
+// cause a link-time error if someone tries to define 2 flags with
+// names like "logging" and "nologging".  We do this because a bool
+// flag FLAG can be set from the command line to true with a "-FLAG"
+// argument, and to false with a "-noFLAG" argument, and so this can
+// potentially avert confusion.
+//
+// We also put flags into their own namespace.  It is purposefully
+// named in an opaque way that people should have trouble typing
+// directly.  The idea is that DEFINE puts the flag in the weird
+// namespace, and DECLARE imports the flag from there into the current
+// namespace.  The net result is to force people to use DECLARE to get
+// access to a flag, rather than saying "extern bool FLAGS_whatever;"
+// or some such instead.  We want this so we can put extra
+// functionality (like sanity-checking) in DECLARE if we want, and
+// make sure it is picked up everywhere.
+//
+// We also put the type of the variable in the namespace, so that
+// people can't DECLARE_int32 something that they DEFINE_bool'd
+// elsewhere.
+
+class FlagRegisterer {
+ public:
+  FlagRegisterer(const char* name, const char* type,
+                 const char* help, const char* filename,
+                 void* current_storage, void* defvalue_storage);
+};
+
+#ifndef SWIG  // In swig, ignore the main flag declarations
+
+// If your application #defines STRIP_FLAG_HELP to a non-zero value
+// before #including this file, we remove the help message from the
+// binary file. This can reduce the size of the resulting binary
+// somewhat, and may also be useful for security reasons.
+
+extern const char kStrippedFlagHelp[];
+
+#if defined(STRIP_FLAG_HELP) && STRIP_FLAG_HELP > 0
+// Need this construct to avoid the 'defined but not used' warning.
+#define MAYBE_STRIPPED_HELP(txt) (false ? (txt) : kStrippedFlagHelp)
+#else
+#define MAYBE_STRIPPED_HELP(txt) txt
+#endif
+
+// Each command-line flag has two variables associated with it: one
+// with the current value, and one with the default value.  However,
+// we have a third variable, which is where value is assigned; it's a
+// constant.  This guarantees that FLAG_##value is initialized at
+// static initialization time (e.g. before program-start) rather than
+// than global construction time (which is after program-start but
+// before main), at least when 'value' is a compile-time constant.  We
+// use a small trick for the "default value" variable, and call it
+// FLAGS_no<name>.  This serves the second purpose of assuring a
+// compile error if someone tries to define a flag named no<name>
+// which is illegal (--foo and --nofoo both affect the "foo" flag).
+#define DEFINE_VARIABLE(type, shorttype, name, value, help) \
+  namespace fL##shorttype {                                     \
+    static const type FLAGS_nono##name = value;                 \
+    type FLAGS_##name = FLAGS_nono##name;                       \
+    type FLAGS_no##name = FLAGS_nono##name;                     \
+    static ::google::FlagRegisterer o_##name(      \
+      #name, #type, MAYBE_STRIPPED_HELP(help), __FILE__,        \
+      &FLAGS_##name, &FLAGS_no##name);                          \
+  }                                                             \
+  using fL##shorttype::FLAGS_##name
+
+#define DECLARE_VARIABLE(type, shorttype, name) \
+  namespace fL##shorttype {                     \
+    extern type FLAGS_##name;                   \
+  }                                             \
+  using fL##shorttype::FLAGS_##name
+
+// For boolean flags, we want to do the extra check that the passed-in
+// value is actually a bool, and not a string or something that can be
+// coerced to a bool.  These declarations (no definition needed!) will
+// help us do that, and never evaluate from, which is important.
+// We'll use 'sizeof(IsBool(val))' to distinguish.
+namespace fLB {
+template<typename From> double IsBoolFlag(const From& from);
+bool IsBoolFlag(bool from);
+}
+extern bool FlagsTypeWarn(const char *name);
+
+#define DECLARE_bool(name)          DECLARE_VARIABLE(bool,B, name)
+// We have extra code here to make sure 'val' is actually a boolean.
+#define DEFINE_bool(name,val,txt)   namespace fLB { \
+                                      const bool FLAGS_nonono##name = \
+                                        (sizeof(::google::fLB::IsBoolFlag(val)) \
+                                        == sizeof(double)) \
+                                        ? ::google::FlagsTypeWarn(#name) : true; \
+                                    } \
+                                    DEFINE_VARIABLE(bool,B, name, val, txt)
+#define DECLARE_int32(name)         DECLARE_VARIABLE(::google::int32,I, name)
+#define DEFINE_int32(name,val,txt)  DEFINE_VARIABLE(::google::int32,I, name, val, txt)
+
+#define DECLARE_int64(name)         DECLARE_VARIABLE(::google::int64,I64, name)
+#define DEFINE_int64(name,val,txt)  DEFINE_VARIABLE(::google::int64,I64, name, val, txt)
+
+#define DECLARE_uint64(name)        DECLARE_VARIABLE(::google::uint64,U64, name)
+#define DEFINE_uint64(name,val,txt) DEFINE_VARIABLE(::google::uint64,U64, name, val, txt)
+
+#define DECLARE_double(name)        DECLARE_VARIABLE(double,D, name)
+#define DEFINE_double(name,val,txt) DEFINE_VARIABLE(double,D, name, val, txt)
+
+// Strings are trickier, because they're not a POD, so we can't
+// construct them at static-initialization time (instead they get
+// constructed at global-constructor time, which is much later).  To
+// try to avoid crashes in that case, we use a char buffer to store
+// the string, which we can static-initialize, and then placement-new
+// into it later.  It's not perfect, but the best we can do.
+#define DECLARE_string(name)  namespace fLS { extern string& FLAGS_##name; } \
+                              using fLS::FLAGS_##name
+
+// We need to define a var named FLAGS_no##name so people don't define
+// --string and --nostring.  And we need a temporary place to put val
+// so we don't have to evaluate it twice.  Two great needs that go
+// great together!
+#define DEFINE_string(name, val, txt)                                     \
+  namespace fLS {                                                         \
+    static union { void* align; char s[sizeof(std::string)]; } s_##name[2]; \
+    const string* const FLAGS_no##name = new (s_##name[0].s) std::string(val); \
+    static ::google::FlagRegisterer o_##name(                \
+      #name, "string", MAYBE_STRIPPED_HELP(txt), __FILE__,                \
+      s_##name[0].s, new (s_##name[1].s) std::string(*FLAGS_no##name));   \
+    std::string& FLAGS_##name = *(reinterpret_cast<std::string*>(s_##name[0].s));   \
+  }                                                                       \
+  using fLS::FLAGS_##name
+
+#endif  // SWIG
+
+}  // namespace google
+
+#endif  // GOOGLE_GFLAGS_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/google/output_string.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/google/output_string.h
new file mode 100644
index 0000000..fc7caad
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/google/output_string.h
@@ -0,0 +1,108 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OPEN_VCDIFF_OUTPUT_STRING_H_
+#define OPEN_VCDIFF_OUTPUT_STRING_H_
+
+#include <cstddef>  // size_t
+
+namespace open_vcdiff {
+
+// This interface allows clients of VCDiff[Streaming]Encoder and
+// VCDiff[Streaming]Decoder to use different string types to receive the output
+// of those interfaces.
+//
+// Only the following operations can be performed on an output string, and their
+// semantics must be identical to the std::string methods of the same names:
+//     append()
+//     clear()
+//     push_back()
+//     size()
+//
+// The versions of these methods that take a std::string argument are not
+// supported by OutputStringInterface.
+//
+// There is one additional operation that can be performed on an output string:
+// ReserveAdditionalBytes().  This asks the underlying output type to reserve
+// enough capacity for the number of additional bytes requested in addition to
+// existing content.  The decoder knows the total expected output size in
+// advance, so one large ReserveAdditionalBytes() operation precedes many small
+// append() operations.  For output types that gain no advantage from knowing in
+// advance how many bytes will be appended, ReserveAdditionalBytes() can be
+// defined to do nothing.
+class OutputStringInterface {
+ public:
+  virtual ~OutputStringInterface() { }
+
+  virtual OutputStringInterface& append(const char* s, size_t n) = 0;
+
+  virtual void clear() = 0;
+
+  virtual void push_back(char c) = 0;
+
+  virtual void ReserveAdditionalBytes(size_t res_arg) = 0;
+
+  virtual size_t size() const = 0;
+};
+
+// This template can be used to wrap any class that supports the operations
+// needed by OutputStringInterface, including std::string.  A class that has
+// different names or syntax for these operations will need specialized
+// definitions of OutputString methods -- see output_string_types.h for some
+// examples of how to do this.
+template<class StringClass>
+class OutputString : public OutputStringInterface {
+ public:
+  explicit OutputString(StringClass* impl) : impl_(impl) { }
+
+  virtual ~OutputString() { }
+
+  virtual OutputString& append(const char* s, size_t n) {
+    impl_->append(s, n);
+    return *this;
+  }
+
+  virtual void clear() {
+    impl_->clear();
+  }
+
+  virtual void push_back(char c) {
+    impl_->push_back(c);
+  }
+
+  virtual void ReserveAdditionalBytes(size_t res_arg) {
+    impl_->reserve(impl_->size() + res_arg);
+  }
+
+  virtual size_t size() const {
+    return impl_->size();
+  }
+
+ private:
+  StringClass* impl_;
+
+  // Making these private avoids implicit copy constructor & assignment operator
+  OutputString(const OutputString&);
+  void operator=(const OutputString&);
+};
+
+// Don't allow the OutputString template to be based upon a pointer to
+// OutputStringInterface.  Enforce this restriction by defining this class to
+// lack any functions expected of an OutputString.
+template<> class OutputString<OutputStringInterface> { };
+
+}  // namespace open_vcdiff
+
+#endif  // OPEN_VCDIFF_OUTPUT_STRING_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/google/vcdecoder.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/google/vcdecoder.h
new file mode 100644
index 0000000..f8a44f8
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/google/vcdecoder.h
@@ -0,0 +1,189 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OPEN_VCDIFF_VCDECODER_H_
+#define OPEN_VCDIFF_VCDECODER_H_
+
+#include <cstddef>  // size_t
+#include <string>
+#include "google/output_string.h"
+
+namespace open_vcdiff {
+
+using std::string;
+
+class VCDiffStreamingDecoderImpl;
+
+// A streaming decoder class.  Takes a dictionary (source) file and a delta
+// file, and produces the original target file.  It is intended to process
+// the partial contents of the delta file as they arrive, in "chunks".
+// As soon as a chunk of bytes is received from a file read or from a network
+// transmission, it can be passed to DecodeChunk(), which will then output
+// as much of the target file as it can.
+//
+// The client should use this class as follows:
+//    VCDiffStreamingDecoder v;
+//    v.StartDecoding(dictionary_ptr, dictionary_size);
+//    while (any data left) {
+//      if (!v.DecodeChunk(data, len, &output_string)) {
+//        handle error;
+//        break;
+//      }
+//      process(output_string);  // might have no new data, though
+//    }
+//    if (!v.FinishDecoding()) { ... handle error ... }
+//
+// I.e., the allowed pattern of calls is
+//    StartDecoding DecodeChunk* FinishDecoding
+//
+// NOTE: It is not necessary to call FinishDecoding if DecodeChunk
+//       returns false.  When DecodeChunk returns false to signal an
+//       error, it resets its state and is ready for a new StartDecoding.
+//       If FinishDecoding is called, it will also return false.
+//
+class VCDiffStreamingDecoder {
+ public:
+  VCDiffStreamingDecoder();
+  ~VCDiffStreamingDecoder();
+
+  // Resets the dictionary contents to "dictionary_ptr[0,dictionary_size-1]"
+  // and sets up the data structures for decoding.  Note that the dictionary
+  // contents are not copied, and the client is responsible for ensuring that
+  // dictionary_ptr is valid until FinishDecoding is called.
+  //
+  void StartDecoding(const char* dictionary_ptr, size_t dictionary_size);
+
+  // Accepts "data[0,len-1]" as additional data received in the
+  // compressed stream.  If any chunks of data can be fully decoded,
+  // they are appended to output_string.
+  //
+  // Returns true on success, and false if the data was malformed
+  // or if there was an error in decoding it (e.g. out of memory, etc.).
+  //
+  // Note: we *append*, so the old contents of output_string stick around.
+  // This convention differs from the non-streaming Encode/Decode
+  // interfaces in VCDiffDecoder.
+  //
+  // output_string is guaranteed to be resized no more than once for each
+  // window in the VCDIFF delta file.  This rule is irrespective
+  // of the number of calls to DecodeString().
+  //
+  template<class OutputType>
+  bool DecodeChunk(const char* data, size_t len, OutputType* output) {
+    OutputString<OutputType> output_string(output);
+    return DecodeChunkToInterface(data, len, &output_string);
+  }
+
+  bool DecodeChunkToInterface(const char* data, size_t len,
+                              OutputStringInterface* output_string);
+
+  // Finishes decoding after all data has been received.  Returns true
+  // if decoding of the entire stream was successful.  FinishDecoding()
+  // must be called for the current target before StartDecoding() can be
+  // called for a different target.
+  //
+  bool FinishDecoding();
+
+  // The decoder can create a version of the output target string with XML tags
+  // added to indicate where each section of the decoded text came from.  This
+  // can assist in debugging the decoder and/or determining the effectiveness of
+  // a particular dictionary.  The following XML tags will be added.  Despite
+  // the formatting of this example, newlines will not be added between tags.
+  //     <dmatch>This text matched with the dictionary</dmatch>
+  //     <bmatch>This text matched earlier target output</bmatch>
+  //     <literal>This text found no match</literal>
+  //
+  // Calling EnableAnnotatedOutput() will enable this feature.  The interface
+  // GetAnnotatedOutput() can be used to retrieve the annotated text.   It is
+  // recommended to use this feature only when the target data consists of HTML
+  // or other human-readable text.
+
+  // Enables the annotated output feature.  After this method is called, new
+  // target windows added to output_string by DecodeChunk() will also be added
+  // to the annotated output, and can be retrieved using GetAnnotatedOutput().
+  // If annotated output is already enabled, this function has no effect.
+  void EnableAnnotatedOutput();
+
+  // Disables the annotated output feature.  After calling this method,
+  // GetAnnotatedOutput() will produce an empty string until
+  // EnableAnnotatedOutput() is called again.
+  void DisableAnnotatedOutput();
+
+  // Replaces annotated_output with a copy of the annotated output string.
+  // Annotated output collection begins when EnableAnnotatedOutput() is called.
+  // The annotated output will be cleared each time StartDecoding() is called,
+  // but not when FinishDecoding() is called.
+  template<class OutputType>
+  void GetAnnotatedOutput(OutputType* annotated_output) {
+    OutputString<OutputType> output_string(annotated_output);
+    GetAnnotatedOutputToInterface(&output_string);
+  }
+
+  void GetAnnotatedOutputToInterface(OutputStringInterface* annotated_output);
+
+ private:
+  VCDiffStreamingDecoderImpl* const impl_;
+
+  // Make the copy constructor and assignment operator private
+  // so that they don't inadvertently get used.
+  explicit VCDiffStreamingDecoder(const VCDiffStreamingDecoder&);
+  void operator=(const VCDiffStreamingDecoder&);
+};
+
+// A simpler (non-streaming) interface to the VCDIFF decoder that can be used
+// if the entire delta file is available.
+//
+class VCDiffDecoder {
+ public:
+  VCDiffDecoder() { }
+  ~VCDiffDecoder() { }
+
+  /***** Simple interface *****/
+
+  // Replaces old contents of "*target" with the result of decoding
+  // the bytes found in "encoding."
+  //
+  // Returns true if "encoding" was a well-formed sequence of
+  // instructions, and returns false if not.
+  //
+  template<class OutputType>
+  bool Decode(const char* dictionary_ptr,
+              size_t dictionary_size,
+              const string& encoding,
+              OutputType* target) {
+    OutputString<OutputType> output_string(target);
+    return DecodeToInterface(dictionary_ptr,
+                             dictionary_size,
+                             encoding,
+                             &output_string);
+  }
+
+ private:
+  bool DecodeToInterface(const char* dictionary_ptr,
+                         size_t dictionary_size,
+                         const string& encoding,
+                         OutputStringInterface* target);
+
+  VCDiffStreamingDecoder decoder_;
+
+  // Make the copy constructor and assignment operator private
+  // so that they don't inadvertently get used.
+  explicit VCDiffDecoder(const VCDiffDecoder&);
+  void operator=(const VCDiffDecoder&);
+};
+
+};  // namespace open_vcdiff
+
+#endif  // OPEN_VCDIFF_VCDECODER_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/google/vcencoder.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/google/vcencoder.h
new file mode 100644
index 0000000..6faff76
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/google/vcencoder.h
@@ -0,0 +1,287 @@
+// Copyright 2007 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OPEN_VCDIFF_VCENCODER_H_
+#define OPEN_VCDIFF_VCENCODER_H_
+
+#include <cstddef>  // size_t
+#include <vector>
+#include "google/output_string.h"
+
+namespace open_vcdiff {
+
+class VCDiffEngine;
+class VCDiffStreamingEncoderImpl;
+
+// These flags are passed to the constructor of VCDiffStreamingEncoder
+// to determine whether certain open-vcdiff format extensions
+// (which are not part of the RFC 3284 draft standard for VCDIFF)
+// are employed.
+//
+// Because these extensions are not part of the VCDIFF standard, if
+// any of these flags except VCD_STANDARD_FORMAT is specified, then the caller
+// must be certain that the receiver of the data will be using open-vcdiff
+// to decode the delta file, or at least that the receiver can interpret
+// these extensions.  The encoder will use an 'S' as the fourth character
+// in the delta file to indicate that non-standard extensions are being used.
+//
+enum VCDiffFormatExtensionFlagValues {
+  // No extensions: the encoded format will conform to the RFC
+  // draft standard for VCDIFF.
+  VCD_STANDARD_FORMAT = 0x00,
+  // If this flag is specified, then the encoder writes each delta file
+  // window by interleaving instructions and sizes with their corresponding
+  // addresses and data, rather than placing these elements
+  // into three separate sections.  This facilitates providing partially
+  // decoded results when only a portion of a delta file window is received
+  // (e.g. when HTTP over TCP is used as the transmission protocol.)
+  VCD_FORMAT_INTERLEAVED = 0x01,
+  // If this flag is specified, then an Adler32 checksum
+  // of the target window data is included in the delta window.
+  VCD_FORMAT_CHECKSUM = 0x02
+};
+
+typedef int VCDiffFormatExtensionFlags;
+
+// A HashedDictionary must be constructed from the dictionary data
+// in order to use VCDiffStreamingEncoder.  If the same dictionary will
+// be used to perform several encoding operations, then the caller should
+// create the HashedDictionary once and cache it for reuse.  This object
+// is thread-safe: the same const HashedDictionary can be used
+// by several threads simultaneously, each with its own VCDiffStreamingEncoder.
+//
+// dictionary_contents is copied into the HashedDictionary, so the
+// caller may free that string, if desired, after the constructor returns.
+//
+class HashedDictionary {
+ public:
+  HashedDictionary(const char* dictionary_contents,
+                   size_t dictionary_size);
+  ~HashedDictionary();
+
+  // Init() must be called before using the HashedDictionary as an argument
+  // to the VCDiffStreamingEncoder, or for any other purpose except
+  // destruction.  It returns true if initialization succeeded, or false
+  // if an error occurred, in which case the caller should destroy the object
+  // without using it.
+  bool Init();
+
+  const VCDiffEngine* engine() const { return engine_; }
+
+ private:
+  const VCDiffEngine* engine_;
+};
+
+// The standard streaming interface to the VCDIFF (RFC 3284) encoder.
+// "Streaming" in this context means that, even though the entire set of
+// input data to be encoded may not be available at once, the encoder
+// can produce partial output based on what is available.  Of course,
+// the caller should try to maximize the sizes of the data chunks passed
+// to the encoder.
+class VCDiffStreamingEncoder {
+ public:
+  // The HashedDictionary object passed to the constructor must remain valid,
+  // without being deleted, for the lifetime of the VCDiffStreamingEncoder
+  // object.
+  //
+  // format_extensions allows certain open-vcdiff extensions to the VCDIFF
+  // format to be included in the encoded output.  These extensions are not
+  // part of the RFC 3284 draft standard, so specifying any extension flags
+  // will make the output compatible only with open-vcdiff, or with other
+  // VCDIFF implementations that accept these extensions.  See above for an
+  // explanation of each possible flag value.
+  //
+  // *** look_for_target_matches:
+  // The VCDIFF format allows COPY instruction addresses to reference data from
+  // the source (dictionary), or from previously encoded target data.
+  //
+  // If look_for_target_matches is false, then the encoder will only
+  // produce COPY instructions that reference source data from the dictionary,
+  // never from previously encoded target data.  This will speed up the encoding
+  // process, but the encoded data will not be as compact.
+  //
+  // If this value is true, then the encoder will produce COPY instructions
+  // that reference either source data or target data.  A COPY instruction from
+  // the previously encoded target data may even extend into the range of the
+  // data being produced by that same COPY instruction; for example, if the
+  // previously encoded target data is "LA", then a single COPY instruction of
+  // length 10 can produce the additional target data "LALALALALA".
+  //
+  // There is a third type of COPY instruction that starts within
+  // the source data and extends from the end of the source data
+  // into the beginning of the target data.  This VCDIFF encoder will never
+  // produce a COPY instruction of this third type (regardless of the value of
+  // look_for_target_matches) because the cost of checking for matches
+  // across the source-target boundary would not justify its benefits.
+  //
+  VCDiffStreamingEncoder(const HashedDictionary* dictionary,
+                         VCDiffFormatExtensionFlags format_extensions,
+                         bool look_for_target_matches);
+  ~VCDiffStreamingEncoder();
+
+  // The client should use these routines as follows:
+  //    HashedDictionary hd(dictionary, dictionary_size);
+  //    if (!hd.Init()) {
+  //      HandleError();
+  //      return;
+  //    }
+  //    string output_string;
+  //    VCDiffStreamingEncoder v(hd, false, false);
+  //    if (!v.StartEncoding(&output_string)) {
+  //      HandleError();
+  //      return;  // No need to call FinishEncoding()
+  //    }
+  //    Process(output_string.data(), output_string.size());
+  //    output_string.clear();
+  //    while (get data_buf) {
+  //      if (!v.EncodeChunk(data_buf, data_len, &output_string)) {
+  //        HandleError();
+  //        return;  // No need to call FinishEncoding()
+  //      }
+  //      // The encoding is appended to output_string at each call,
+  //      // so clear output_string once its contents have been processed.
+  //      Process(output_string.data(), output_string.size());
+  //      output_string.clear();
+  //    }
+  //    if (!v.FinishEncoding(&output_string)) {
+  //      HandleError();
+  //      return;
+  //    }
+  //    Process(output_string.data(), output_string.size());
+  //    output_string.clear();
+  //
+  // I.e., the allowed pattern of calls is
+  //    StartEncoding EncodeChunk* FinishEncoding
+  //
+  // The size of the encoded output depends on the sizes of the chunks
+  // passed in (i.e. the chunking boundary affects compression).
+  // However the decoded output is independent of chunk boundaries.
+
+  // Sets up the data structures for encoding.
+  // Writes a VCDIFF delta file header (as defined in RFC section 4.1)
+  // to *output_string.
+  //
+  // Note: we *append*, so the old contents of *output_string stick around.
+  // This convention differs from the non-streaming Encode/Decode
+  // interfaces in VCDiffEncoder.
+  //
+  // If an error occurs, this function returns false; otherwise it returns true.
+  // If this function returns false, the caller does not need to call
+  // FinishEncoding or to do any cleanup except destroying the
+  // VCDiffStreamingEncoder object.
+  template<class OutputType>
+  bool StartEncoding(OutputType* output) {
+    OutputString<OutputType> output_string(output);
+    return StartEncodingToInterface(&output_string);
+  }
+
+  bool StartEncodingToInterface(OutputStringInterface* output_string);
+
+  // Appends compressed encoding for "data" (one complete VCDIFF delta window)
+  // to *output_string.
+  // If an error occurs (for example, if StartEncoding was not called
+  // earlier or StartEncoding returned false), this function returns false;
+  // otherwise it returns true.  The caller does not need to call FinishEncoding
+  // or do any cleanup except destroying the VCDiffStreamingEncoder
+  // if this function returns false.
+  template<class OutputType>
+  bool EncodeChunk(const char* data, size_t len, OutputType* output) {
+    OutputString<OutputType> output_string(output);
+    return EncodeChunkToInterface(data, len, &output_string);
+  }
+
+  bool EncodeChunkToInterface(const char* data, size_t len,
+                              OutputStringInterface* output_string);
+
+  // Finishes encoding and appends any leftover encoded data to *output_string.
+  // If an error occurs (for example, if StartEncoding was not called
+  // earlier or StartEncoding returned false), this function returns false;
+  // otherwise it returns true.  The caller does not need to
+  // do any cleanup except destroying the VCDiffStreamingEncoder
+  // if this function returns false.
+  template<class OutputType>
+  bool FinishEncoding(OutputType* output) {
+    OutputString<OutputType> output_string(output);
+    return FinishEncodingToInterface(&output_string);
+  }
+
+  bool FinishEncodingToInterface(OutputStringInterface* output_string);
+
+  // Replaces the contents of match_counts with a vector of integers,
+  // one for each possible match length.  The value of match_counts[n]
+  // is equal to the number of matches of length n found so far
+  // for this VCDiffStreamingEncoder object.
+  void GetMatchCounts(std::vector<int>* match_counts) const;
+
+ private:
+  VCDiffStreamingEncoderImpl* const impl_;
+
+  // Make the copy constructor and assignment operator private
+  // so that they don't inadvertently get used.
+  VCDiffStreamingEncoder(const VCDiffStreamingEncoder&);  // NOLINT
+  void operator=(const VCDiffStreamingEncoder&);
+};
+
+// A simpler (non-streaming) interface to the VCDIFF encoder that can be used
+// if the entire target data string is available.
+//
+class VCDiffEncoder {
+ public:
+  VCDiffEncoder(const char* dictionary_contents, size_t dictionary_size)
+      : dictionary_(dictionary_contents, dictionary_size),
+        encoder_(NULL),
+        flags_(VCD_STANDARD_FORMAT) { }
+
+  ~VCDiffEncoder() {
+    delete encoder_;
+  }
+
+  // By default, VCDiffEncoder uses standard VCDIFF format.  This function
+  // can be used before calling Encode(), to specify that interleaved format
+  // and/or checksum format should be used.
+  void SetFormatFlags(VCDiffFormatExtensionFlags flags) { flags_ = flags; }
+
+  // Replaces old contents of output_string with the encoded form of
+  // target_data.
+  template<class OutputType>
+  bool Encode(const char* target_data,
+              size_t target_len,
+              OutputType* output) {
+    OutputString<OutputType> output_string(output);
+    return EncodeToInterface(target_data, target_len, &output_string);
+  }
+
+ private:
+  // Always look for matches in both source and target.  This default value
+  // can be changed in this code if desired.
+  static const bool look_for_target_matches_ = true;
+
+  bool EncodeToInterface(const char* target_data,
+                         size_t target_len,
+                         OutputStringInterface* output_string);
+
+  HashedDictionary dictionary_;
+  VCDiffStreamingEncoder* encoder_;
+  VCDiffFormatExtensionFlags flags_;
+
+  // Make the copy constructor and assignment operator private
+  // so that they don't inadvertently get used.
+  VCDiffEncoder(const VCDiffEncoder&);  // NOLINT
+  void operator=(const VCDiffEncoder&);
+};
+
+}  // namespace open_vcdiff
+
+#endif  // OPEN_VCDIFF_VCENCODER_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/README b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/README
new file mode 100644
index 0000000..e684823
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/README
@@ -0,0 +1,157 @@
+*** NOTE: The files in the open-vcdiff/src/gtest directory are only a subset of
+***       the full Google Test package.  If you want to use Google Test with a
+***       project other than open-vcdiff, please do not use this bundled copy.
+***       Instead, please download the latest version of Google Test from:
+***           http://code.google.com/p/googletest/
+
+Google C++ Testing Framework
+============================
+http://code.google.com/p/googletest/
+
+Overview
+--------
+Google's framework for writing C++ tests on a variety of platforms (Linux, Mac
+OS X, Windows, Windows CE, and Symbian). Based on the xUnit architecture.
+Supports automatic test discovery, a rich set of assertions, user-defined
+assertions, death tests, fatal and non-fatal failures, various options for
+running the tests, and XML test report generation.
+
+Please see the project page above for more information as well as mailing lists
+for questions, discussions, and development. There is also an IRC channel on
+OFTC (irc.oftc.net) #gtest available. Please join us!
+
+Requirements
+------------
+Google Test is designed to have fairly minimal requirements to build and use
+with your projects, but there are some. Currently, the only Operating System
+(OS) on which Google Test is known to build properly is Linux, but we are
+actively working on Windows and Mac support as well. The source code itself is
+already portable across many other platforms, but we are still developing
+robust build systems for each.
+
+### Linux Requirements ###
+These are the base requirements to build and use Google Test from a source
+package (as described below):
+  * GNU-compatible Make or "gmake"
+  * POSIX-standard shell
+  * POSIX(-2) Regular Expressions (regex.h)
+  * A C++98 standards compliant compiler
+
+Furthermore, if you are building Google Test from a VCS Checkout (also
+described below), there are further requirements:
+  * Automake version 1.9 or newer
+  * Autoconf version 2.59 or newer
+  * Libtool / Libtoolize
+  * Python version 2.4 or newer
+
+### Windows Requirements ###
+  * Microsoft Visual Studio 7.1 or newer
+
+### Cygwin Requirements ###
+  * Cygwin 1.5.25-14 or newer
+
+### Mac OS X Requirements ###
+  * Mac OS X 10.4 Tiger or newer
+
+Getting the Source
+------------------
+There are two primary ways of getting Google Test's source code: you can
+download a source release in your preferred archive format, or directly check
+out the source from a Version Control System (VCS, we use Google Code's
+Subversion hosting). The VCS checkout requires a few extra steps and some extra
+software packages on your system, but lets you track development, and make
+patches to contribute much more easily, so we highly encourage it.
+
+### VCS Checkout: ###
+The first step is to select whether you want to check out the main line of
+development on Google Test, or one of the released branches. The former will be
+much more active and have the latest features, but the latter provides much
+more stability and predictability. Choose whichever fits your needs best, and
+proceed with the following Subversion commands:
+
+  $ svn checkout http://googletest.googlecode.com/svn/trunk/ gtest-svn
+
+or for a release version X.Y.*'s branch:
+
+  $ svn checkout http://googletest.googlecode.com/svn/branches/release-X.Y/ gtest-X.Y-svn
+
+Next you will need to prepare the GNU Autotools build system, if you
+are using Linux, Mac OS X, or Cygwin. Enter the target directory of
+the checkout command you used ('gtest-svn' or 'gtest-X.Y-svn' above)
+and proceed with the following commands:
+
+  $ aclocal-1.9       # Where "1.9" must match the following automake command.
+  $ libtoolize -c     # Use "glibtoolize -c" instead on Mac OS X.
+  $ autoheader
+  $ automake-1.9 -ac  # See Automake version requirements above.
+  $ autoconf
+
+While this is a bit complicated, it will most often be automatically re-run by
+your "make" invocations, so in practice you shouldn't need to worry too much.
+Once you have completed these steps, you are ready to build the library. 
+
+### Source Package: ###
+Google Test is also released in source packages which can be downloaded from
+its Google Code download page[1]. Several different archive formats are
+provided, but the only difference is the tools used to manipulate them, and the
+size of the resulting file. Download whichever you are most comfortable with.
+
+  [1] Google Test Downloads: http://code.google.com/p/googletest/downloads/list
+
+Once downloaded expand the archive using whichever tools you prefer for that
+type. This will always result in a new directory with the name "gtest-X.Y.Z"
+which contains all of the source code. Here are some examples in Linux:
+
+  $ tar -xvzf gtest-X.Y.Z.tar.gz
+  $ tar -xvjf gtest-X.Y.Z.tar.bz2
+  $ unzip gtest-X.Y.Z.zip
+
+Building the Source
+-------------------
+
+### Linux, Mac OS X, and Cygwin ###
+There are two primary options for building the source at this point: build it
+inside the source code tree, or in a separate directory. We recommend building
+in a separate directory as that tends to produce both more consistent results
+and be easier to clean up should anything go wrong, but both patterns are
+supported. The only hard restriction is that while the build directory can be
+a subdirectory of the source directory, the opposite is not possible and will
+result in errors. Once you have selected where you wish to build Google Test,
+create the directory if necessary, and enter it. The following steps apply for
+either approach by simply substituting the shell variable SRCDIR with "." for
+building inside the source directory, and the relative path to the source
+directory otherwise.
+
+  $ ${SRCDIR}/configure  # Standard GNU configure script, --help for more info
+  $ make  # Standard makefile following GNU conventions
+  $ make check  # Builds and runs all tests - all should pass
+
+Other programs will only be able to use Google Test's functionality if you
+install it in a location which they can access, in Linux this is typically
+under '/usr/local'. The following command will install all of the Google Test
+libraries, public headers, and utilities necessary for other programs and
+libraries to leverage it:
+
+  $ sudo make install  # Not necessary, but allows use by other programs
+
+TODO(chandlerc@google.com): This section needs to be expanded when the
+'gtest-config' script is finished and Autoconf macro's are provided (or not
+provided) in order to properly reflect the process for other programs to
+locate, include, and link against Google Test.
+
+Finally, should you need to remove Google Test from your system after having
+installed it, run the following command, and it will back out its changes.
+However, note carefully that you must run this command on the *same* Google
+Test build that you ran the install from, or the results are not predictable.
+If you install Google Test on your system, and are working from a VCS checkout,
+make sure you run this *before* updating your checkout of the source in order
+to uninstall the same version which you installed.
+
+  $ sudo make uninstall  # Must be run against the exact same build as "install"
+
+### Windows ###
+Open the gtest.sln file in the msvc/ folder using Visual Studio, and
+you are ready to build Google Test the same way you build any Visual
+Studio project.
+
+Happy testing!
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-death-test.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-death-test.cc
new file mode 100644
index 0000000..919fb53
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-death-test.cc
@@ -0,0 +1,751 @@
+// Copyright 2005, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// This file implements death tests.
+
+#include <gtest/gtest-death-test.h>
+#include <gtest/internal/gtest-port.h>
+
+#include <errno.h>
+#include <limits.h>
+#include <stdarg.h>
+
+#include <gtest/gtest-message.h>
+#include <gtest/internal/gtest-string.h>
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick is to
+// prevent a user from accidentally including gtest-internal-inl.h in
+// his code.
+#define GTEST_IMPLEMENTATION
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION
+
+namespace testing {
+
+// Constants.
+
+// The default death test style.
+static const char kDefaultDeathTestStyle[] = "fast";
+
+GTEST_DEFINE_string(
+    death_test_style,
+    internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle),
+    "Indicates how to run a death test in a forked child process: "
+    "\"threadsafe\" (child process re-executes the test binary "
+    "from the beginning, running only the specific death test) or "
+    "\"fast\" (child process runs the death test immediately "
+    "after forking).");
+
+namespace internal {
+GTEST_DEFINE_string(
+    internal_run_death_test, "",
+    "Indicates the file, line number, temporal index of "
+    "the single death test to run, and a file descriptor to "
+    "which a success code may be sent, all separated by "
+    "colons.  This flag is specified if and only if the current "
+    "process is a sub-process launched for running a thread-safe "
+    "death test.  FOR INTERNAL USE ONLY.");
+}  // namespace internal
+
+#ifdef GTEST_HAS_DEATH_TEST
+
+// ExitedWithCode constructor.
+ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {
+}
+
+// ExitedWithCode function-call operator.
+bool ExitedWithCode::operator()(int exit_status) const {
+  return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_;
+}
+
+// KilledBySignal constructor.
+KilledBySignal::KilledBySignal(int signum) : signum_(signum) {
+}
+
+// KilledBySignal function-call operator.
+bool KilledBySignal::operator()(int exit_status) const {
+  return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_;
+}
+
+namespace internal {
+
+// Utilities needed for death tests.
+
+// Generates a textual description of a given exit code, in the format
+// specified by wait(2).
+static String ExitSummary(int exit_code) {
+  Message m;
+  if (WIFEXITED(exit_code)) {
+    m << "Exited with exit status " << WEXITSTATUS(exit_code);
+  } else if (WIFSIGNALED(exit_code)) {
+    m << "Terminated by signal " << WTERMSIG(exit_code);
+  }
+#ifdef WCOREDUMP
+  if (WCOREDUMP(exit_code)) {
+    m << " (core dumped)";
+  }
+#endif
+  return m.GetString();
+}
+
+// Returns true if exit_status describes a process that was terminated
+// by a signal, or exited normally with a nonzero exit code.
+bool ExitedUnsuccessfully(int exit_status) {
+  return !ExitedWithCode(0)(exit_status);
+}
+
+// Generates a textual failure message when a death test finds more than
+// one thread running, or cannot determine the number of threads, prior
+// to executing the given statement.  It is the responsibility of the
+// caller not to pass a thread_count of 1.
+static String DeathTestThreadWarning(size_t thread_count) {
+  Message msg;
+  msg << "Death tests use fork(), which is unsafe particularly"
+      << " in a threaded context. For this test, " << GTEST_NAME << " ";
+  if (thread_count == 0)
+    msg << "couldn't detect the number of threads.";
+  else
+    msg << "detected " << thread_count << " threads.";
+  return msg.GetString();
+}
+
+// Static string containing a description of the outcome of the
+// last death test.
+static String last_death_test_message;
+
+// Flag characters for reporting a death test that did not die.
+static const char kDeathTestLived = 'L';
+static const char kDeathTestReturned = 'R';
+static const char kDeathTestInternalError = 'I';
+
+// An enumeration describing all of the possible ways that a death test
+// can conclude.  DIED means that the process died while executing the
+// test code; LIVED means that process lived beyond the end of the test
+// code; and RETURNED means that the test statement attempted a "return,"
+// which is not allowed.  IN_PROGRESS means the test has not yet
+// concluded.
+enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED };
+
+// Routine for aborting the program which is safe to call from an
+// exec-style death test child process, in which case the the error
+// message is propagated back to the parent process.  Otherwise, the
+// message is simply printed to stderr.  In either case, the program
+// then exits with status 1.
+void DeathTestAbort(const char* format, ...) {
+  // This function may be called from a threadsafe-style death test
+  // child process, which operates on a very small stack.  Use the
+  // heap for any additional non-miniscule memory requirements.
+  const InternalRunDeathTestFlag* const flag =
+      GetUnitTestImpl()->internal_run_death_test_flag();
+  va_list args;
+  va_start(args, format);
+
+  if (flag != NULL) {
+    FILE* parent = fdopen(flag->status_fd, "w");
+    fputc(kDeathTestInternalError, parent);
+    vfprintf(parent, format, args);
+    fclose(parent);
+    va_end(args);
+    _exit(1);
+  } else {
+    vfprintf(stderr, format, args);
+    va_end(args);
+    abort();
+  }
+}
+
+// A replacement for CHECK that calls DeathTestAbort if the assertion
+// fails.
+#define GTEST_DEATH_TEST_CHECK(expression) \
+  do { \
+    if (!(expression)) { \
+      DeathTestAbort("CHECK failed: File %s, line %d: %s", \
+                     __FILE__, __LINE__, #expression); \
+    } \
+  } while (0)
+
+// This macro is similar to GTEST_DEATH_TEST_CHECK, but it is meant for
+// evaluating any system call that fulfills two conditions: it must return
+// -1 on failure, and set errno to EINTR when it is interrupted and
+// should be tried again.  The macro expands to a loop that repeatedly
+// evaluates the expression as long as it evaluates to -1 and sets
+// errno to EINTR.  If the expression evaluates to -1 but errno is
+// something other than EINTR, DeathTestAbort is called.
+#define GTEST_DEATH_TEST_CHECK_SYSCALL(expression) \
+  do { \
+    int retval; \
+    do { \
+      retval = (expression); \
+    } while (retval == -1 && errno == EINTR); \
+    if (retval == -1) { \
+      DeathTestAbort("CHECK failed: File %s, line %d: %s != -1", \
+                     __FILE__, __LINE__, #expression); \
+    } \
+  } while (0)
+
+// Death test constructor.  Increments the running death test count
+// for the current test.
+DeathTest::DeathTest() {
+  TestInfo* const info = GetUnitTestImpl()->current_test_info();
+  if (info == NULL) {
+    DeathTestAbort("Cannot run a death test outside of a TEST or "
+                   "TEST_F construct");
+  }
+}
+
+// Creates and returns a death test by dispatching to the current
+// death test factory.
+bool DeathTest::Create(const char* statement, const RE* regex,
+                       const char* file, int line, DeathTest** test) {
+  return GetUnitTestImpl()->death_test_factory()->Create(
+      statement, regex, file, line, test);
+}
+
+const char* DeathTest::LastMessage() {
+  return last_death_test_message.c_str();
+}
+
+// ForkingDeathTest provides implementations for most of the abstract
+// methods of the DeathTest interface.  Only the AssumeRole method is
+// left undefined.
+class ForkingDeathTest : public DeathTest {
+ public:
+  ForkingDeathTest(const char* statement, const RE* regex);
+
+  // All of these virtual functions are inherited from DeathTest.
+  virtual int Wait();
+  virtual bool Passed(bool status_ok);
+  virtual void Abort(AbortReason reason);
+
+ protected:
+  void set_forked(bool forked) { forked_ = forked; }
+  void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
+  void set_read_fd(int fd) { read_fd_ = fd; }
+  void set_write_fd(int fd) { write_fd_ = fd; }
+
+ private:
+  // The textual content of the code this object is testing.
+  const char* const statement_;
+  // The regular expression which test output must match.
+  const RE* const regex_;
+  // True if the death test successfully forked.
+  bool forked_;
+  // PID of child process during death test; 0 in the child process itself.
+  pid_t child_pid_;
+  // File descriptors for communicating the death test's status byte.
+  int read_fd_;   // Always -1 in the child process.
+  int write_fd_;  // Always -1 in the parent process.
+  // The exit status of the child process.
+  int status_;
+  // How the death test concluded.
+  DeathTestOutcome outcome_;
+};
+
+// Constructs a ForkingDeathTest.
+ForkingDeathTest::ForkingDeathTest(const char* statement, const RE* regex)
+    : DeathTest(),
+      statement_(statement),
+      regex_(regex),
+      forked_(false),
+      child_pid_(-1),
+      read_fd_(-1),
+      write_fd_(-1),
+      status_(-1),
+      outcome_(IN_PROGRESS) {
+}
+
+// Reads an internal failure message from a file descriptor, then calls
+// LOG(FATAL) with that message.  Called from a death test parent process
+// to read a failure message from the death test child process.
+static void FailFromInternalError(int fd) {
+  Message error;
+  char buffer[256];
+  ssize_t num_read;
+
+  do {
+    while ((num_read = read(fd, buffer, 255)) > 0) {
+      buffer[num_read] = '\0';
+      error << buffer;
+    }
+  } while (num_read == -1 && errno == EINTR);
+
+  // TODO(smcafee):  Maybe just FAIL the test instead?
+  if (num_read == 0) {
+    GTEST_LOG(FATAL, error);
+  } else {
+    GTEST_LOG(FATAL,
+              Message() << "Error while reading death test internal: "
+              << strerror(errno) << " [" << errno << "]");
+  }
+}
+
+// Waits for the child in a death test to exit, returning its exit
+// status, or 0 if no child process exists.  As a side effect, sets the
+// outcome data member.
+int ForkingDeathTest::Wait() {
+  if (!forked_)
+    return 0;
+
+  // The read() here blocks until data is available (signifying the
+  // failure of the death test) or until the pipe is closed (signifying
+  // its success), so it's okay to call this in the parent before
+  // the child process has exited.
+  char flag;
+  ssize_t bytes_read;
+
+  do {
+    bytes_read = read(read_fd_, &flag, 1);
+  } while (bytes_read == -1 && errno == EINTR);
+
+  if (bytes_read == 0) {
+    outcome_ = DIED;
+  } else if (bytes_read == 1) {
+    switch (flag) {
+      case kDeathTestReturned:
+        outcome_ = RETURNED;
+        break;
+      case kDeathTestLived:
+        outcome_ = LIVED;
+        break;
+      case kDeathTestInternalError:
+        FailFromInternalError(read_fd_);  // Does not return.
+        break;
+      default:
+        GTEST_LOG(FATAL,
+                  Message() << "Death test child process reported unexpected "
+                  << "status byte (" << static_cast<unsigned int>(flag)
+                  << ")");
+    }
+  } else {
+    GTEST_LOG(FATAL,
+              Message() << "Read from death test child process failed: "
+              << strerror(errno));
+  }
+
+  GTEST_DEATH_TEST_CHECK_SYSCALL(close(read_fd_));
+  GTEST_DEATH_TEST_CHECK_SYSCALL(waitpid(child_pid_, &status_, 0));
+  return status_;
+}
+
+// Assesses the success or failure of a death test, using both private
+// members which have previously been set, and one argument:
+//
+// Private data members:
+//   outcome:  an enumeration describing how the death test
+//             concluded: DIED, LIVED, or RETURNED.  The death test fails
+//             in the latter two cases
+//   status:   the exit status of the child process, in the format
+//             specified by wait(2)
+//   regex:    a regular expression object to be applied to
+//             the test's captured standard error output; the death test
+//             fails if it does not match
+//
+// Argument:
+//   status_ok: true if exit_status is acceptable in the context of
+//              this particular death test, which fails if it is false
+//
+// Returns true iff all of the above conditions are met.  Otherwise, the
+// first failing condition, in the order given above, is the one that is
+// reported. Also sets the static variable last_death_test_message.
+bool ForkingDeathTest::Passed(bool status_ok) {
+  if (!forked_)
+    return false;
+
+#if GTEST_HAS_GLOBAL_STRING
+  const ::string error_message = GetCapturedStderr();
+#else
+  const ::std::string error_message = GetCapturedStderr();
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+  bool success = false;
+  Message buffer;
+
+  buffer << "Death test: " << statement_ << "\n";
+  switch (outcome_) {
+    case LIVED:
+      buffer << "    Result: failed to die.\n"
+             << " Error msg: " << error_message;
+      break;
+    case RETURNED:
+      buffer << "    Result: illegal return in test statement.\n"
+             << " Error msg: " << error_message;
+      break;
+    case DIED:
+      if (status_ok) {
+        if (RE::PartialMatch(error_message, *regex_)) {
+          success = true;
+        } else {
+          buffer << "    Result: died but not with expected error.\n"
+                 << "  Expected: " << regex_->pattern() << "\n"
+                 << "Actual msg: " << error_message;
+        }
+      } else {
+        buffer << "    Result: died but not with expected exit code:\n"
+               << "            " << ExitSummary(status_) << "\n";
+      }
+      break;
+    default:
+      GTEST_LOG(FATAL,
+                "DeathTest::Passed somehow called before conclusion of test");
+  }
+
+  last_death_test_message = buffer.GetString();
+  return success;
+}
+
+// Signals that the death test code which should have exited, didn't.
+// Should be called only in a death test child process.
+// Writes a status byte to the child's status file desriptor, then
+// calls _exit(1).
+void ForkingDeathTest::Abort(AbortReason reason) {
+  // The parent process considers the death test to be a failure if
+  // it finds any data in our pipe.  So, here we write a single flag byte
+  // to the pipe, then exit.
+  const char flag =
+      reason == TEST_DID_NOT_DIE ? kDeathTestLived : kDeathTestReturned;
+  GTEST_DEATH_TEST_CHECK_SYSCALL(write(write_fd_, &flag, 1));
+  GTEST_DEATH_TEST_CHECK_SYSCALL(close(write_fd_));
+  _exit(1);  // Exits w/o any normal exit hooks (we were supposed to crash)
+}
+
+// A concrete death test class that forks, then immediately runs the test
+// in the child process.
+class NoExecDeathTest : public ForkingDeathTest {
+ public:
+  NoExecDeathTest(const char* statement, const RE* regex) :
+      ForkingDeathTest(statement, regex) { }
+  virtual TestRole AssumeRole();
+};
+
+// The AssumeRole process for a fork-and-run death test.  It implements a
+// straightforward fork, with a simple pipe to transmit the status byte.
+DeathTest::TestRole NoExecDeathTest::AssumeRole() {
+  const size_t thread_count = GetThreadCount();
+  if (thread_count != 1) {
+    GTEST_LOG(WARNING, DeathTestThreadWarning(thread_count));
+  }
+
+  int pipe_fd[2];
+  GTEST_DEATH_TEST_CHECK(pipe(pipe_fd) != -1);
+
+  last_death_test_message = "";
+  CaptureStderr();
+  // When we fork the process below, the log file buffers are copied, but the
+  // file descriptors are shared.  We flush all log files here so that closing
+  // the file descriptors in the child process doesn't throw off the
+  // synchronization between descriptors and buffers in the parent process.
+  // This is as close to the fork as possible to avoid a race condition in case
+  // there are multiple threads running before the death test, and another
+  // thread writes to the log file.
+  FlushInfoLog();
+
+  const pid_t child_pid = fork();
+  GTEST_DEATH_TEST_CHECK(child_pid != -1);
+  set_child_pid(child_pid);
+  if (child_pid == 0) {
+    GTEST_DEATH_TEST_CHECK_SYSCALL(close(pipe_fd[0]));
+    set_write_fd(pipe_fd[1]);
+    // Redirects all logging to stderr in the child process to prevent
+    // concurrent writes to the log files.  We capture stderr in the parent
+    // process and append the child process' output to a log.
+    LogToStderr();
+    return EXECUTE_TEST;
+  } else {
+    GTEST_DEATH_TEST_CHECK_SYSCALL(close(pipe_fd[1]));
+    set_read_fd(pipe_fd[0]);
+    set_forked(true);
+    return OVERSEE_TEST;
+  }
+}
+
+// A concrete death test class that forks and re-executes the main
+// program from the beginning, with command-line flags set that cause
+// only this specific death test to be run.
+class ExecDeathTest : public ForkingDeathTest {
+ public:
+  ExecDeathTest(const char* statement, const RE* regex,
+                const char* file, int line) :
+      ForkingDeathTest(statement, regex), file_(file), line_(line) { }
+  virtual TestRole AssumeRole();
+ private:
+  // The name of the file in which the death test is located.
+  const char* const file_;
+  // The line number on which the death test is located.
+  const int line_;
+};
+
+// Utility class for accumulating command-line arguments.
+class Arguments {
+ public:
+  Arguments() {
+    args_.push_back(NULL);
+  }
+  ~Arguments() {
+    for (std::vector<char*>::iterator i = args_.begin();
+         i + 1 != args_.end();
+         ++i) {
+      free(*i);
+    }
+  }
+  void AddArgument(const char* argument) {
+    args_.insert(args_.end() - 1, strdup(argument));
+  }
+
+  template <typename Str>
+  void AddArguments(const ::std::vector<Str>& arguments) {
+    for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
+         i != arguments.end();
+         ++i) {
+      args_.insert(args_.end() - 1, strdup(i->c_str()));
+    }
+  }
+  char* const* Argv() {
+    return &args_[0];
+  }
+ private:
+  std::vector<char*> args_;
+};
+
+// A struct that encompasses the arguments to the child process of a
+// threadsafe-style death test process.
+struct ExecDeathTestArgs {
+  char* const* argv;  // Command-line arguments for the child's call to exec
+  int close_fd;       // File descriptor to close; the read end of a pipe
+};
+
+// The main function for a threadsafe-style death test child process.
+static int ExecDeathTestChildMain(void* child_arg) {
+  ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg);
+  GTEST_DEATH_TEST_CHECK_SYSCALL(close(args->close_fd));
+  execve(args->argv[0], args->argv, environ);
+  DeathTestAbort("execve failed: %s", strerror(errno));
+  return EXIT_FAILURE;
+}
+
+// Two utility routines that together determine the direction the stack
+// grows.
+// This could be accomplished more elegantly by a single recursive
+// function, but we want to guard against the unlikely possibility of
+// a smart compiler optimizing the recursion away.
+static bool StackLowerThanAddress(const void* ptr) {
+  int dummy;
+  return &dummy < ptr;
+}
+
+static bool StackGrowsDown() {
+  int dummy;
+  return StackLowerThanAddress(&dummy);
+}
+
+// A threadsafe implementation of fork(2) for threadsafe-style death tests
+// that uses clone(2).  It dies with an error message if anything goes
+// wrong.
+static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
+  static const bool stack_grows_down = StackGrowsDown();
+  const size_t stack_size = getpagesize();
+  void* const stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE,
+                           MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  GTEST_DEATH_TEST_CHECK(stack != MAP_FAILED);
+  void* const stack_top =
+      static_cast<char*>(stack) + (stack_grows_down ? stack_size : 0);
+  ExecDeathTestArgs args = { argv, close_fd };
+  const pid_t child_pid = clone(&ExecDeathTestChildMain, stack_top,
+                                SIGCHLD, &args);
+  GTEST_DEATH_TEST_CHECK(child_pid != -1);
+  GTEST_DEATH_TEST_CHECK(munmap(stack, stack_size) != -1);
+  return child_pid;
+}
+
+// The AssumeRole process for a fork-and-exec death test.  It re-executes the
+// main program from the beginning, setting the --gtest_filter
+// and --gtest_internal_run_death_test flags to cause only the current
+// death test to be re-run.
+DeathTest::TestRole ExecDeathTest::AssumeRole() {
+  const UnitTestImpl* const impl = GetUnitTestImpl();
+  const InternalRunDeathTestFlag* const flag =
+      impl->internal_run_death_test_flag();
+  const TestInfo* const info = impl->current_test_info();
+  const int death_test_index = info->result()->death_test_count();
+
+  if (flag != NULL) {
+    set_write_fd(flag->status_fd);
+    return EXECUTE_TEST;
+  }
+
+  int pipe_fd[2];
+  GTEST_DEATH_TEST_CHECK(pipe(pipe_fd) != -1);
+  // Clear the close-on-exec flag on the write end of the pipe, lest
+  // it be closed when the child process does an exec:
+  GTEST_DEATH_TEST_CHECK(fcntl(pipe_fd[1], F_SETFD, 0) != -1);
+
+  const String filter_flag =
+      String::Format("--%s%s=%s.%s",
+                     GTEST_FLAG_PREFIX, kFilterFlag,
+                     info->test_case_name(), info->name());
+  const String internal_flag =
+      String::Format("--%s%s=%s:%d:%d:%d",
+                     GTEST_FLAG_PREFIX, kInternalRunDeathTestFlag, file_, line_,
+                     death_test_index, pipe_fd[1]);
+  Arguments args;
+  args.AddArguments(GetArgvs());
+  args.AddArgument("--logtostderr");
+  args.AddArgument(filter_flag.c_str());
+  args.AddArgument(internal_flag.c_str());
+
+  last_death_test_message = "";
+
+  CaptureStderr();
+  // See the comment in NoExecDeathTest::AssumeRole for why the next line
+  // is necessary.
+  FlushInfoLog();
+
+  const pid_t child_pid = ExecDeathTestFork(args.Argv(), pipe_fd[0]);
+  GTEST_DEATH_TEST_CHECK_SYSCALL(close(pipe_fd[1]));
+  set_child_pid(child_pid);
+  set_read_fd(pipe_fd[0]);
+  set_forked(true);
+  return OVERSEE_TEST;
+}
+
+// Creates a concrete DeathTest-derived class that depends on the
+// --gtest_death_test_style flag, and sets the pointer pointed to
+// by the "test" argument to its address.  If the test should be
+// skipped, sets that pointer to NULL.  Returns true, unless the
+// flag is set to an invalid value.
+bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex,
+                                     const char* file, int line,
+                                     DeathTest** test) {
+  UnitTestImpl* const impl = GetUnitTestImpl();
+  const InternalRunDeathTestFlag* const flag =
+      impl->internal_run_death_test_flag();
+  const int death_test_index = impl->current_test_info()
+      ->increment_death_test_count();
+
+  if (flag != NULL) {
+    if (death_test_index > flag->index) {
+      last_death_test_message = String::Format(
+          "Death test count (%d) somehow exceeded expected maximum (%d)",
+          death_test_index, flag->index);
+      return false;
+    }
+
+    if (!(flag->file == file && flag->line == line &&
+          flag->index == death_test_index)) {
+      *test = NULL;
+      return true;
+    }
+  }
+
+  if (GTEST_FLAG(death_test_style) == "threadsafe") {
+    *test = new ExecDeathTest(statement, regex, file, line);
+  } else if (GTEST_FLAG(death_test_style) == "fast") {
+    *test = new NoExecDeathTest(statement, regex);
+  } else {
+    last_death_test_message = String::Format(
+        "Unknown death test style \"%s\" encountered",
+        GTEST_FLAG(death_test_style).c_str());
+    return false;
+  }
+
+  return true;
+}
+
+// Splits a given string on a given delimiter, populating a given
+// vector with the fields.  GTEST_HAS_DEATH_TEST implies that we have
+// ::std::string, so we can use it here.
+static void SplitString(const ::std::string& str, char delimiter,
+                        ::std::vector< ::std::string>* dest) {
+  ::std::vector< ::std::string> parsed;
+  ::std::string::size_type pos = 0;
+  while (true) {
+    const ::std::string::size_type colon = str.find(delimiter, pos);
+    if (colon == ::std::string::npos) {
+      parsed.push_back(str.substr(pos));
+      break;
+    } else {
+      parsed.push_back(str.substr(pos, colon - pos));
+      pos = colon + 1;
+    }
+  }
+  dest->swap(parsed);
+}
+
+// Attempts to parse a string into a positive integer.  Returns true
+// if that is possible.  GTEST_HAS_DEATH_TEST implies that we have
+// ::std::string, so we can use it here.
+static bool ParsePositiveInt(const ::std::string& str, int* number) {
+  // Fail fast if the given string does not begin with a digit;
+  // this bypasses strtol's "optional leading whitespace and plus
+  // or minus sign" semantics, which are undesirable here.
+  if (str.empty() || !isdigit(str[0])) {
+    return false;
+  }
+  char* endptr;
+  const long parsed = strtol(str.c_str(), &endptr, 10);  // NOLINT
+  if (*endptr == '\0' && parsed <= INT_MAX) {
+    *number = static_cast<int>(parsed);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+// Returns a newly created InternalRunDeathTestFlag object with fields
+// initialized from the GTEST_FLAG(internal_run_death_test) flag if
+// the flag is specified; otherwise returns NULL.
+InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
+  if (GTEST_FLAG(internal_run_death_test) == "") return NULL;
+
+  InternalRunDeathTestFlag* const internal_run_death_test_flag =
+      new InternalRunDeathTestFlag;
+  // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
+  // can use it here.
+  ::std::vector< ::std::string> fields;
+  SplitString(GTEST_FLAG(internal_run_death_test).c_str(), ':', &fields);
+  if (fields.size() != 4
+      || !ParsePositiveInt(fields[1], &internal_run_death_test_flag->line)
+      || !ParsePositiveInt(fields[2], &internal_run_death_test_flag->index)
+      || !ParsePositiveInt(fields[3],
+                           &internal_run_death_test_flag->status_fd)) {
+    DeathTestAbort("Bad --gtest_internal_run_death_test flag: %s",
+                   GTEST_FLAG(internal_run_death_test).c_str());
+  }
+  internal_run_death_test_flag->file = fields[0].c_str();
+  return internal_run_death_test_flag;
+}
+
+}  // namespace internal
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+}  // namespace testing
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-death-test.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-death-test.h
new file mode 100644
index 0000000..cbd41fe
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-death-test.h
@@ -0,0 +1,205 @@
+// Copyright 2005, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file defines the public API for death tests.  It is
+// #included by gtest.h so a user doesn't need to include this
+// directly.
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
+#define GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
+
+#include <gtest/internal/gtest-death-test-internal.h>
+
+namespace testing {
+
+// This flag controls the style of death tests.  Valid values are "threadsafe",
+// meaning that the death test child process will re-execute the test binary
+// from the start, running only a single death test, or "fast",
+// meaning that the child process will execute the test logic immediately
+// after forking.
+GTEST_DECLARE_string(death_test_style);
+
+#ifdef GTEST_HAS_DEATH_TEST
+
+// The following macros are useful for writing death tests.
+
+// Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is
+// executed:
+//
+//   1. The assertion fails immediately if there are more than one
+//   active threads.  This is because it's safe to fork() only when
+//   there is a single thread.
+//
+//   2. The parent process forks a sub-process and runs the death test
+//   in it; the sub-process exits with code 0 at the end of the death
+//   test, if it hasn't exited already.
+//
+//   3. The parent process waits for the sub-process to terminate.
+//
+//   4. The parent process checks the exit code and error message of
+//   the sub-process.
+//
+// Note:
+//
+// It's not safe to call exit() if the current process is forked from
+// a multi-threaded process, so people usually call _exit() instead in
+// such a case.  However, we are not concerned with this as we run
+// death tests only when there is a single thread.  Since exit() has a
+// cleaner semantics (it also calls functions registered with atexit()
+// and on_exit()), this macro calls exit() instead of _exit() to
+// terminate the child process.
+//
+// Examples:
+//
+//   ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number");
+//   for (int i = 0; i < 5; i++) {
+//     EXPECT_DEATH(server.ProcessRequest(i),
+//                  "Invalid request .* in ProcessRequest()")
+//         << "Failed to die on request " << i);
+//   }
+//
+//   ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting");
+//
+//   bool KilledBySIGHUP(int exit_code) {
+//     return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP;
+//   }
+//
+//   ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!");
+
+// Asserts that a given statement causes the program to exit, with an
+// integer exit status that satisfies predicate, and emitting error output
+// that matches regex.
+#define ASSERT_EXIT(statement, predicate, regex) \
+  GTEST_DEATH_TEST(statement, predicate, regex, GTEST_FATAL_FAILURE)
+
+// Like ASSERT_EXIT, but continues on to successive tests in the
+// test case, if any:
+#define EXPECT_EXIT(statement, predicate, regex) \
+  GTEST_DEATH_TEST(statement, predicate, regex, GTEST_NONFATAL_FAILURE)
+
+// Asserts that a given statement causes the program to exit, either by
+// explicitly exiting with a nonzero exit code or being killed by a
+// signal, and emitting error output that matches regex.
+#define ASSERT_DEATH(statement, regex) \
+  ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
+
+// Like ASSERT_DEATH, but continues on to successive tests in the
+// test case, if any:
+#define EXPECT_DEATH(statement, regex) \
+  EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
+
+// Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*:
+
+// Tests that an exit code describes a normal exit with a given exit code.
+class ExitedWithCode {
+ public:
+  explicit ExitedWithCode(int exit_code);
+  bool operator()(int exit_status) const;
+ private:
+  const int exit_code_;
+};
+
+// Tests that an exit code describes an exit due to termination by a
+// given signal.
+class KilledBySignal {
+ public:
+  explicit KilledBySignal(int signum);
+  bool operator()(int exit_status) const;
+ private:
+  const int signum_;
+};
+
+// EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode.
+// The death testing framework causes this to have interesting semantics,
+// since the sideeffects of the call are only visible in opt mode, and not
+// in debug mode.
+//
+// In practice, this can be used to test functions that utilize the
+// LOG(DFATAL) macro using the following style:
+//
+// int DieInDebugOr12(int* sideeffect) {
+//   if (sideeffect) {
+//     *sideeffect = 12;
+//   }
+//   LOG(DFATAL) << "death";
+//   return 12;
+// }
+//
+// TEST(TestCase, TestDieOr12WorksInDgbAndOpt) {
+//   int sideeffect = 0;
+//   // Only asserts in dbg.
+//   EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death");
+//
+// #ifdef NDEBUG
+//   // opt-mode has sideeffect visible.
+//   EXPECT_EQ(12, sideeffect);
+// #else
+//   // dbg-mode no visible sideeffect.
+//   EXPECT_EQ(0, sideeffect);
+// #endif
+// }
+//
+// This will assert that DieInDebugReturn12InOpt() crashes in debug
+// mode, usually due to a DCHECK or LOG(DFATAL), but returns the
+// appropriate fallback value (12 in this case) in opt mode. If you
+// need to test that a function has appropriate side-effects in opt
+// mode, include assertions against the side-effects.  A general
+// pattern for this is:
+//
+// EXPECT_DEBUG_DEATH({
+//   // Side-effects here will have an effect after this statement in
+//   // opt mode, but none in debug mode.
+//   EXPECT_EQ(12, DieInDebugOr12(&sideeffect));
+// }, "death");
+//
+#ifdef NDEBUG
+
+#define EXPECT_DEBUG_DEATH(statement, regex) \
+  do { statement; } while (false)
+
+#define ASSERT_DEBUG_DEATH(statement, regex) \
+  do { statement; } while (false)
+
+#else
+
+#define EXPECT_DEBUG_DEATH(statement, regex) \
+  EXPECT_DEATH(statement, regex)
+
+#define ASSERT_DEBUG_DEATH(statement, regex) \
+  ASSERT_DEATH(statement, regex)
+
+#endif  // NDEBUG for EXPECT_DEBUG_DEATH
+#endif  // GTEST_HAS_DEATH_TEST
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-filepath.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-filepath.cc
new file mode 100644
index 0000000..2fba96e
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-filepath.cc
@@ -0,0 +1,208 @@
+// 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.
+//
+// Authors: keith.ray@gmail.com (Keith Ray)
+
+#include <gtest/internal/gtest-filepath.h>
+#include <gtest/internal/gtest-port.h>
+
+#ifdef _WIN32
+#include <direct.h>
+#include <io.h>
+#endif  // _WIN32
+
+#include <sys/stat.h>
+
+#include <gtest/internal/gtest-string.h>
+
+namespace testing {
+namespace internal {
+
+#ifdef GTEST_OS_WINDOWS
+const char kPathSeparator = '\\';
+const char kPathSeparatorString[] = "\\";
+const char kCurrentDirectoryString[] = ".\\";
+#else
+const char kPathSeparator = '/';
+const char kPathSeparatorString[] = "/";
+const char kCurrentDirectoryString[] = "./";
+#endif  // GTEST_OS_WINDOWS
+
+// Returns a copy of the FilePath with the case-insensitive extension removed.
+// Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
+// FilePath("dir/file"). If a case-insensitive extension is not
+// found, returns a copy of the original FilePath.
+FilePath FilePath::RemoveExtension(const char* extension) const {
+  String dot_extension(String::Format(".%s", extension));
+  if (pathname_.EndsWithCaseInsensitive(dot_extension.c_str())) {
+    return FilePath(String(pathname_.c_str(), pathname_.GetLength() - 4));
+  }
+  return *this;
+}
+
+// Returns a copy of the FilePath with the directory part removed.
+// Example: FilePath("path/to/file").RemoveDirectoryName() returns
+// FilePath("file"). If there is no directory part ("just_a_file"), it returns
+// the FilePath unmodified. If there is no file part ("just_a_dir/") it
+// returns an empty FilePath ("").
+// On Windows platform, '\' is the path separator, otherwise it is '/'.
+FilePath FilePath::RemoveDirectoryName() const {
+  const char* const last_sep = strrchr(c_str(), kPathSeparator);
+  return last_sep ? FilePath(String(last_sep + 1)) : *this;
+}
+
+// RemoveFileName returns the directory path with the filename removed.
+// Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
+// If the FilePath is "a_file" or "/a_file", RemoveFileName returns
+// FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
+// not have a file, like "just/a/dir/", it returns the FilePath unmodified.
+// On Windows platform, '\' is the path separator, otherwise it is '/'.
+FilePath FilePath::RemoveFileName() const {
+  const char* const last_sep = strrchr(c_str(), kPathSeparator);
+  return FilePath(last_sep ? String(c_str(), last_sep + 1 - c_str())
+                           : String(kCurrentDirectoryString));
+}
+
+// Helper functions for naming files in a directory for xml output.
+
+// Given directory = "dir", base_name = "test", number = 0,
+// extension = "xml", returns "dir/test.xml". If number is greater
+// than zero (e.g., 12), returns "dir/test_12.xml".
+// On Windows platform, uses \ as the separator rather than /.
+FilePath FilePath::MakeFileName(const FilePath& directory,
+                                const FilePath& base_name,
+                                int number,
+                                const char* extension) {
+  FilePath dir(directory.RemoveTrailingPathSeparator());
+  if (number == 0) {
+    return FilePath(String::Format("%s%c%s.%s", dir.c_str(), kPathSeparator,
+                                   base_name.c_str(), extension));
+  }
+  return FilePath(String::Format("%s%c%s_%d.%s", dir.c_str(), kPathSeparator,
+                                 base_name.c_str(), number, extension));
+}
+
+// Returns true if pathname describes something findable in the file-system,
+// either a file, directory, or whatever.
+bool FilePath::FileOrDirectoryExists() const {
+#ifdef GTEST_OS_WINDOWS
+  struct _stat file_stat = {};
+  return _stat(pathname_.c_str(), &file_stat) == 0;
+#else
+  struct stat file_stat = {};
+  return stat(pathname_.c_str(), &file_stat) == 0;
+#endif  // GTEST_OS_WINDOWS
+}
+
+// Returns true if pathname describes a directory in the file-system
+// that exists.
+bool FilePath::DirectoryExists() const {
+  bool result = false;
+#ifdef _WIN32
+  FilePath removed_sep(this->RemoveTrailingPathSeparator());
+  struct _stat file_stat = {};
+  result = _stat(removed_sep.c_str(), &file_stat) == 0 &&
+      (_S_IFDIR & file_stat.st_mode) != 0;
+#else
+  struct stat file_stat = {};
+  result = stat(pathname_.c_str(), &file_stat) == 0 &&
+      S_ISDIR(file_stat.st_mode);
+#endif  // _WIN32
+  return result;
+}
+
+// Returns a pathname for a file that does not currently exist. The pathname
+// will be directory/base_name.extension or
+// directory/base_name_<number>.extension if directory/base_name.extension
+// already exists. The number will be incremented until a pathname is found
+// that does not already exist.
+// Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
+// There could be a race condition if two or more processes are calling this
+// function at the same time -- they could both pick the same filename.
+FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
+                                          const FilePath& base_name,
+                                          const char* extension) {
+  FilePath full_pathname;
+  int number = 0;
+  do {
+    full_pathname.Set(MakeFileName(directory, base_name, number++, extension));
+  } while (full_pathname.FileOrDirectoryExists());
+  return full_pathname;
+}
+
+// Returns true if FilePath ends with a path separator, which indicates that
+// it is intended to represent a directory. Returns false otherwise.
+// This does NOT check that a directory (or file) actually exists.
+bool FilePath::IsDirectory() const {
+  return pathname_.EndsWith(kPathSeparatorString);
+}
+
+// Create directories so that path exists. Returns true if successful or if
+// the directories already exist; returns false if unable to create directories
+// for any reason.
+bool FilePath::CreateDirectoriesRecursively() const {
+  if (!this->IsDirectory()) {
+    return false;
+  }
+
+  if (pathname_.GetLength() == 0 || this->DirectoryExists()) {
+    return true;
+  }
+
+  const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName());
+  return parent.CreateDirectoriesRecursively() && this->CreateFolder();
+}
+
+// Create the directory so that path exists. Returns true if successful or
+// if the directory already exists; returns false if unable to create the
+// directory for any reason, including if the parent directory does not
+// exist. Not named "CreateDirectory" because that's a macro on Windows.
+bool FilePath::CreateFolder() const {
+#ifdef _WIN32
+  int result = _mkdir(pathname_.c_str());
+#else
+  int result = mkdir(pathname_.c_str(), 0777);
+#endif  // _WIN32
+  if (result == -1) {
+    return this->DirectoryExists();  // An error is OK if the directory exists.
+  }
+  return true;  // No error.
+}
+
+// If input name has a trailing separator character, remove it and return the
+// name, otherwise return the name string unmodified.
+// On Windows platform, uses \ as the separator, other platforms use /.
+FilePath FilePath::RemoveTrailingPathSeparator() const {
+  return pathname_.EndsWith(kPathSeparatorString)
+      ? FilePath(String(pathname_.c_str(), pathname_.GetLength() - 1))
+      : *this;
+}
+
+}  // namespace internal
+}  // namespace testing
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-message.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-message.h
new file mode 100644
index 0000000..b1d646f
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-message.h
@@ -0,0 +1,224 @@
+// Copyright 2005, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file defines the Message class.
+//
+// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
+// leave some internal implementation details in this header file.
+// They are clearly marked by comments like this:
+//
+//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+//
+// Such code is NOT meant to be used by a user directly, and is subject
+// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
+// program!
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
+#define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
+
+#include <gtest/internal/gtest-string.h>
+#include <gtest/internal/gtest-internal.h>
+
+namespace testing {
+
+// The Message class works like an ostream repeater.
+//
+// Typical usage:
+//
+//   1. You stream a bunch of values to a Message object.
+//      It will remember the text in a StrStream.
+//   2. Then you stream the Message object to an ostream.
+//      This causes the text in the Message to be streamed
+//      to the ostream.
+//
+// For example;
+//
+//   testing::Message foo;
+//   foo << 1 << " != " << 2;
+//   std::cout << foo;
+//
+// will print "1 != 2".
+//
+// Message is not intended to be inherited from.  In particular, its
+// destructor is not virtual.
+//
+// Note that StrStream behaves differently in gcc and in MSVC.  You
+// can stream a NULL char pointer to it in the former, but not in the
+// latter (it causes an access violation if you do).  The Message
+// class hides this difference by treating a NULL char pointer as
+// "(null)".
+class Message {
+ private:
+  // The type of basic IO manipulators (endl, ends, and flush) for
+  // narrow streams.
+  typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
+
+ public:
+  // Constructs an empty Message.
+  // We allocate the StrStream separately because it otherwise each use of
+  // ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
+  // stack frame leading to huge stack frames in some cases; gcc does not reuse
+  // the stack space.
+  Message() : ss_(new internal::StrStream) {}
+
+  // Copy constructor.
+  Message(const Message& msg) : ss_(new internal::StrStream) {  // NOLINT
+    *ss_ << msg.GetString();
+  }
+
+  // Constructs a Message from a C-string.
+  explicit Message(const char* str) : ss_(new internal::StrStream) {
+    *ss_ << str;
+  }
+
+  ~Message() { delete ss_; }
+#ifdef __SYMBIAN32__
+  // Streams a value (either a pointer or not) to this object.
+  template <typename T>
+  inline Message& operator <<(const T& value) {
+    StreamHelper(typename internal::is_pointer<T>::type(), value);
+    return *this;
+  }
+#else
+  // Streams a non-pointer value to this object.
+  template <typename T>
+  inline Message& operator <<(const T& val) {
+    ::GTestStreamToHelper(ss_, val);
+    return *this;
+  }
+
+  // Streams a pointer value to this object.
+  //
+  // This function is an overload of the previous one.  When you
+  // stream a pointer to a Message, this definition will be used as it
+  // is more specialized.  (The C++ Standard, section
+  // [temp.func.order].)  If you stream a non-pointer, then the
+  // previous definition will be used.
+  //
+  // The reason for this overload is that streaming a NULL pointer to
+  // ostream is undefined behavior.  Depending on the compiler, you
+  // may get "0", "(nil)", "(null)", or an access violation.  To
+  // ensure consistent result across compilers, we always treat NULL
+  // as "(null)".
+  template <typename T>
+  inline Message& operator <<(T* const& pointer) {  // NOLINT
+    if (pointer == NULL) {
+      *ss_ << "(null)";
+    } else {
+      ::GTestStreamToHelper(ss_, pointer);
+    }
+    return *this;
+  }
+#endif  // __SYMBIAN32__
+
+  // Since the basic IO manipulators are overloaded for both narrow
+  // and wide streams, we have to provide this specialized definition
+  // of operator <<, even though its body is the same as the
+  // templatized version above.  Without this definition, streaming
+  // endl or other basic IO manipulators to Message will confuse the
+  // compiler.
+  Message& operator <<(BasicNarrowIoManip val) {
+    *ss_ << val;
+    return *this;
+  }
+
+  // Instead of 1/0, we want to see true/false for bool values.
+  Message& operator <<(bool b) {
+    return *this << (b ? "true" : "false");
+  }
+
+  // These two overloads allow streaming a wide C string to a Message
+  // using the UTF-8 encoding.
+  Message& operator <<(const wchar_t* wide_c_str) {
+    return *this << internal::String::ShowWideCString(wide_c_str);
+  }
+  Message& operator <<(wchar_t* wide_c_str) {
+    return *this << internal::String::ShowWideCString(wide_c_str);
+  }
+
+#if GTEST_HAS_STD_WSTRING
+  // Converts the given wide string to a narrow string using the UTF-8
+  // encoding, and streams the result to this Message object.
+  Message& operator <<(const ::std::wstring& wstr);
+#endif  // GTEST_HAS_STD_WSTRING
+
+#if GTEST_HAS_GLOBAL_WSTRING
+  // Converts the given wide string to a narrow string using the UTF-8
+  // encoding, and streams the result to this Message object.
+  Message& operator <<(const ::wstring& wstr);
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+  // Gets the text streamed to this object so far as a String.
+  // Each '\0' character in the buffer is replaced with "\\0".
+  //
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  internal::String GetString() const {
+    return internal::StrStreamToString(ss_);
+  }
+
+ private:
+#ifdef __SYMBIAN32__
+  // These are needed as the Nokia Symbian Compiler cannot decide between
+  // const T& and const T* in a function template. The Nokia compiler _can_
+  // decide between class template specializations for T and T*, so a
+  // tr1::type_traits-like is_pointer works, and we can overload on that.
+  template <typename T>
+  inline void StreamHelper(internal::true_type dummy, T* pointer) {
+    if (pointer == NULL) {
+      *ss_ << "(null)";
+    } else {
+      ::GTestStreamToHelper(ss_, pointer);
+    }
+  }
+  template <typename T>
+  inline void StreamHelper(internal::false_type dummy, const T& value) {
+    ::GTestStreamToHelper(ss_, value);
+  }
+#endif  // __SYMBIAN32__
+
+  // We'll hold the text streamed to this object here.
+  internal::StrStream* const ss_;
+
+  // We declare (but don't implement) this to prevent the compiler
+  // from implementing the assignment operator.
+  void operator=(const Message&);
+};
+
+// Streams a Message to an ostream.
+inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
+  return os << sb.GetString();
+}
+
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-port.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-port.cc
new file mode 100644
index 0000000..2a4d37a
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-port.cc
@@ -0,0 +1,292 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include <gtest/internal/gtest-port.h>
+
+#include <limits.h>
+#ifdef GTEST_HAS_DEATH_TEST
+#include <regex.h>
+#endif  // GTEST_HAS_DEATH_TEST
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <gtest/gtest-spi.h>
+#include <gtest/gtest-message.h>
+#include <gtest/internal/gtest-string.h>
+
+namespace testing {
+namespace internal {
+
+#ifdef GTEST_HAS_DEATH_TEST
+
+// Implements RE.  Currently only needed for death tests.
+
+RE::~RE() {
+  regfree(&regex_);
+  free(const_cast<char*>(pattern_));
+}
+
+// Returns true iff str contains regular expression re.
+bool RE::PartialMatch(const char* str, const RE& re) {
+  if (!re.is_valid_) return false;
+
+  regmatch_t match;
+  return regexec(&re.regex_, str, 1, &match, 0) == 0;
+}
+
+// Initializes an RE from its string representation.
+void RE::Init(const char* regex) {
+  pattern_ = strdup(regex);
+  is_valid_ = regcomp(&regex_, regex, REG_EXTENDED) == 0;
+  EXPECT_TRUE(is_valid_)
+      << "Regular expression \"" << regex
+      << "\" is not a valid POSIX Extended regular expression.";
+}
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Logs a message at the given severity level.
+void GTestLog(GTestLogSeverity severity, const char* file,
+              int line, const char* msg) {
+  const char* const marker =
+      severity == GTEST_INFO ?    "[  INFO ]" :
+      severity == GTEST_WARNING ? "[WARNING]" :
+      severity == GTEST_ERROR ?   "[ ERROR ]" : "[ FATAL ]";
+  fprintf(stderr, "\n%s %s:%d: %s\n", marker, file, line, msg);
+  if (severity == GTEST_FATAL) {
+    abort();
+  }
+}
+
+#ifdef GTEST_HAS_DEATH_TEST
+
+// Defines the stderr capturer.
+
+class CapturedStderr {
+ public:
+  // The ctor redirects stderr to a temporary file.
+  CapturedStderr() {
+    uncaptured_fd_ = dup(STDERR_FILENO);
+
+    char name_template[] = "captured_stderr.XXXXXX";
+    const int captured_fd = mkstemp(name_template);
+    filename_ = name_template;
+    fflush(NULL);
+    dup2(captured_fd, STDERR_FILENO);
+    close(captured_fd);
+  }
+
+  ~CapturedStderr() {
+    remove(filename_.c_str());
+  }
+
+  // Stops redirecting stderr.
+  void StopCapture() {
+    // Restores the original stream.
+    fflush(NULL);
+    dup2(uncaptured_fd_, STDERR_FILENO);
+    close(uncaptured_fd_);
+    uncaptured_fd_ = -1;
+  }
+
+  // Returns the name of the temporary file holding the stderr output.
+  // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
+  // can use it here.
+  ::std::string filename() const { return filename_; }
+
+ private:
+  int uncaptured_fd_;
+  ::std::string filename_;
+};
+
+static CapturedStderr* g_captured_stderr = NULL;
+
+// Returns the size (in bytes) of a file.
+static size_t GetFileSize(FILE * file) {
+  fseek(file, 0, SEEK_END);
+  return static_cast<size_t>(ftell(file));
+}
+
+// Reads the entire content of a file as a string.
+// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can
+// use it here.
+static ::std::string ReadEntireFile(FILE * file) {
+  const size_t file_size = GetFileSize(file);
+  char* const buffer = new char[file_size];
+
+  size_t bytes_last_read = 0;  // # of bytes read in the last fread()
+  size_t bytes_read = 0;       // # of bytes read so far
+
+  fseek(file, 0, SEEK_SET);
+
+  // Keeps reading the file until we cannot read further or the
+  // pre-determined file size is reached.
+  do {
+    bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file);
+    bytes_read += bytes_last_read;
+  } while (bytes_last_read > 0 && bytes_read < file_size);
+
+  const ::std::string content(buffer, buffer+bytes_read);
+  delete[] buffer;
+
+  return content;
+}
+
+// Starts capturing stderr.
+void CaptureStderr() {
+  if (g_captured_stderr != NULL) {
+    GTEST_LOG(FATAL, "Only one stderr capturer can exist at one time.");
+  }
+  g_captured_stderr = new CapturedStderr;
+}
+
+// Stops capturing stderr and returns the captured string.
+// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can
+// use it here.
+::std::string GetCapturedStderr() {
+  g_captured_stderr->StopCapture();
+  FILE* const file = fopen(g_captured_stderr->filename().c_str(), "r");
+  const ::std::string content = ReadEntireFile(file);
+  fclose(file);
+
+  delete g_captured_stderr;
+  g_captured_stderr = NULL;
+
+  return content;
+}
+
+// A copy of all command line arguments.  Set by InitGoogleTest().
+::std::vector<String> g_argvs;
+
+// Returns the command line as a vector of strings.
+const ::std::vector<String>& GetArgvs() { return g_argvs; }
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Returns the name of the environment variable corresponding to the
+// given flag.  For example, FlagToEnvVar("foo") will return
+// "GTEST_FOO" in the open-source version.
+static String FlagToEnvVar(const char* flag) {
+  const String full_flag = (Message() << GTEST_FLAG_PREFIX << flag).GetString();
+
+  Message env_var;
+  for (int i = 0; i != full_flag.GetLength(); i++) {
+    env_var << static_cast<char>(toupper(full_flag.c_str()[i]));
+  }
+
+  return env_var.GetString();
+}
+
+// Reads and returns the Boolean environment variable corresponding to
+// the given flag; if it's not set, returns default_value.
+//
+// The value is considered true iff it's not "0".
+bool BoolFromGTestEnv(const char* flag, bool default_value) {
+  const String env_var = FlagToEnvVar(flag);
+  const char* const string_value = GetEnv(env_var.c_str());
+  return string_value == NULL ?
+      default_value : strcmp(string_value, "0") != 0;
+}
+
+// Parses 'str' for a 32-bit signed integer.  If successful, writes
+// the result to *value and returns true; otherwise leaves *value
+// unchanged and returns false.
+bool ParseInt32(const Message& src_text, const char* str, Int32* value) {
+  // Parses the environment variable as a decimal integer.
+  char* end = NULL;
+  const long long_value = strtol(str, &end, 10);  // NOLINT
+
+  // Has strtol() consumed all characters in the string?
+  if (*end != '\0') {
+    // No - an invalid character was encountered.
+    Message msg;
+    msg << "WARNING: " << src_text
+        << " is expected to be a 32-bit integer, but actually"
+        << " has value \"" << str << "\".\n";
+    printf("%s", msg.GetString().c_str());
+    fflush(stdout);
+    return false;
+  }
+
+  // Is the parsed value in the range of an Int32?
+  const Int32 result = static_cast<Int32>(long_value);
+  if (long_value == LONG_MAX || long_value == LONG_MIN ||
+      // The parsed value overflows as a long.  (strtol() returns
+      // LONG_MAX or LONG_MIN when the input overflows.)
+      result != long_value
+      // The parsed value overflows as an Int32.
+      ) {
+    Message msg;
+    msg << "WARNING: " << src_text
+        << " is expected to be a 32-bit integer, but actually"
+        << " has value " << str << ", which overflows.\n";
+    printf("%s", msg.GetString().c_str());
+    fflush(stdout);
+    return false;
+  }
+
+  *value = result;
+  return true;
+}
+
+// Reads and returns a 32-bit integer stored in the environment
+// variable corresponding to the given flag; if it isn't set or
+// doesn't represent a valid 32-bit integer, returns default_value.
+Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
+  const String env_var = FlagToEnvVar(flag);
+  const char* const string_value = GetEnv(env_var.c_str());
+  if (string_value == NULL) {
+    // The environment variable is not set.
+    return default_value;
+  }
+
+  Int32 result = default_value;
+  if (!ParseInt32(Message() << "Environment variable " << env_var,
+                  string_value, &result)) {
+    printf("The default value %s is used.\n",
+           (Message() << default_value).GetString().c_str());
+    fflush(stdout);
+    return default_value;
+  }
+
+  return result;
+}
+
+// Reads and returns the string environment variable corresponding to
+// the given flag; if it's not set, returns default_value.
+const char* StringFromGTestEnv(const char* flag, const char* default_value) {
+  const String env_var = FlagToEnvVar(flag);
+  const char* const value = GetEnv(env_var.c_str());
+  return value == NULL ? default_value : value;
+}
+
+}  // namespace internal
+}  // namespace testing
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-spi.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-spi.h
new file mode 100644
index 0000000..75d0dcf
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest-spi.h
@@ -0,0 +1,247 @@
+// Copyright 2007, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// Utilities for testing Google Test itself and code that uses Google Test
+// (e.g. frameworks built on top of Google Test).
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_
+#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_
+
+#include <gtest/gtest.h>
+
+namespace testing {
+
+// A copyable object representing the result of a test part (i.e. an
+// assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()).
+//
+// Don't inherit from TestPartResult as its destructor is not virtual.
+class TestPartResult {
+ public:
+  // C'tor.  TestPartResult does NOT have a default constructor.
+  // Always use this constructor (with parameters) to create a
+  // TestPartResult object.
+  TestPartResult(TestPartResultType type,
+                 const char* file_name,
+                 int line_number,
+                 const char* message)
+      : type_(type),
+        file_name_(file_name),
+        line_number_(line_number),
+        message_(message) {
+  }
+
+  // Gets the outcome of the test part.
+  TestPartResultType type() const { return type_; }
+
+  // Gets the name of the source file where the test part took place, or
+  // NULL if it's unknown.
+  const char* file_name() const { return file_name_.c_str(); }
+
+  // Gets the line in the source file where the test part took place,
+  // or -1 if it's unknown.
+  int line_number() const { return line_number_; }
+
+  // Gets the message associated with the test part.
+  const char* message() const { return message_.c_str(); }
+
+  // Returns true iff the test part passed.
+  bool passed() const { return type_ == TPRT_SUCCESS; }
+
+  // Returns true iff the test part failed.
+  bool failed() const { return type_ != TPRT_SUCCESS; }
+
+  // Returns true iff the test part non-fatally failed.
+  bool nonfatally_failed() const { return type_ == TPRT_NONFATAL_FAILURE; }
+
+  // Returns true iff the test part fatally failed.
+  bool fatally_failed() const { return type_ == TPRT_FATAL_FAILURE; }
+ private:
+  TestPartResultType type_;
+
+  // The name of the source file where the test part took place, or
+  // NULL if the source file is unknown.
+  internal::String file_name_;
+  // The line in the source file where the test part took place, or -1
+  // if the line number is unknown.
+  int line_number_;
+  internal::String message_;  // The test failure message.
+};
+
+// Prints a TestPartResult object.
+std::ostream& operator<<(std::ostream& os, const TestPartResult& result);
+
+// An array of TestPartResult objects.
+//
+// We define this class as we cannot use STL containers when compiling
+// Google Test with MSVC 7.1 and exceptions disabled.
+//
+// Don't inherit from TestPartResultArray as its destructor is not
+// virtual.
+class TestPartResultArray {
+ public:
+  TestPartResultArray();
+  ~TestPartResultArray();
+
+  // Appends the given TestPartResult to the array.
+  void Append(const TestPartResult& result);
+
+  // Returns the TestPartResult at the given index (0-based).
+  const TestPartResult& GetTestPartResult(int index) const;
+
+  // Returns the number of TestPartResult objects in the array.
+  int size() const;
+ private:
+  // Internally we use a list to simulate the array.  Yes, this means
+  // that random access is O(N) in time, but it's OK for its purpose.
+  internal::List<TestPartResult>* const list_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN(TestPartResultArray);
+};
+
+// This interface knows how to report a test part result.
+class TestPartResultReporterInterface {
+ public:
+  virtual ~TestPartResultReporterInterface() {}
+
+  virtual void ReportTestPartResult(const TestPartResult& result) = 0;
+};
+
+// This helper class can be used to mock out Google Test failure reporting
+// so that we can test Google Test or code that builds on Google Test.
+//
+// An object of this class appends a TestPartResult object to the
+// TestPartResultArray object given in the constructor whenever a
+// Google Test failure is reported.
+class ScopedFakeTestPartResultReporter
+    : public TestPartResultReporterInterface {
+ public:
+  // The c'tor sets this object as the test part result reporter used
+  // by Google Test.  The 'result' parameter specifies where to report the
+  // results.
+  explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);
+
+  // The d'tor restores the previous test part result reporter.
+  virtual ~ScopedFakeTestPartResultReporter();
+
+  // Appends the TestPartResult object to the TestPartResultArray
+  // received in the constructor.
+  //
+  // This method is from the TestPartResultReporterInterface
+  // interface.
+  virtual void ReportTestPartResult(const TestPartResult& result);
+ private:
+  TestPartResultReporterInterface* const old_reporter_;
+  TestPartResultArray* const result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN(ScopedFakeTestPartResultReporter);
+};
+
+namespace internal {
+
+// A helper class for implementing EXPECT_FATAL_FAILURE() and
+// EXPECT_NONFATAL_FAILURE().  Its destructor verifies that the given
+// TestPartResultArray contains exactly one failure that has the given
+// type and contains the given substring.  If that's not the case, a
+// non-fatal failure will be generated.
+class SingleFailureChecker {
+ public:
+  // The constructor remembers the arguments.
+  SingleFailureChecker(const TestPartResultArray* results,
+                       TestPartResultType type,
+                       const char* substr);
+  ~SingleFailureChecker();
+ private:
+  const TestPartResultArray* const results_;
+  const TestPartResultType type_;
+  const String substr_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN(SingleFailureChecker);
+};
+
+}  // namespace internal
+
+}  // namespace testing
+
+// A macro for testing Google Test assertions or code that's expected to
+// generate Google Test fatal failures.  It verifies that the given
+// statement will cause exactly one fatal Google Test failure with 'substr'
+// being part of the failure message.
+//
+// Implementation note: The verification is done in the destructor of
+// SingleFailureChecker, to make sure that it's done even when
+// 'statement' throws an exception.
+//
+// Known restrictions:
+//   - 'statement' cannot reference local non-static variables or
+//     non-static members of the current object.
+//   - 'statement' cannot return a value.
+//   - You cannot stream a failure message to this macro.
+#define EXPECT_FATAL_FAILURE(statement, substr) do {\
+    class GTestExpectFatalFailureHelper {\
+     public:\
+      static void Execute() { statement; }\
+    };\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TPRT_FATAL_FAILURE, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          &gtest_failures);\
+      GTestExpectFatalFailureHelper::Execute();\
+    }\
+  } while (false)
+
+// A macro for testing Google Test assertions or code that's expected to
+// generate Google Test non-fatal failures.  It asserts that the given
+// statement will cause exactly one non-fatal Google Test failure with
+// 'substr' being part of the failure message.
+//
+// 'statement' is allowed to reference local variables and members of
+// the current object.
+//
+// Implementation note: The verification is done in the destructor of
+// SingleFailureChecker, to make sure that it's done even when
+// 'statement' throws an exception or aborts the function.
+//
+// Known restrictions:
+//   - You cannot stream a failure message to this macro.
+#define EXPECT_NONFATAL_FAILURE(statement, substr) do {\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TPRT_NONFATAL_FAILURE, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          &gtest_failures);\
+      statement;\
+    }\
+  } while (false)
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_SPI_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest.cc
new file mode 100644
index 0000000..235ec5a
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest.cc
@@ -0,0 +1,3545 @@
+// Copyright 2005, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// The Google C++ Testing Framework (Google Test)
+
+#include <gtest/gtest.h>
+#include <gtest/gtest-spi.h>
+
+#include <ctype.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef GTEST_OS_LINUX
+
+// TODO(kenton@google.com): Use autoconf to detect availability of
+// gettimeofday().
+#define GTEST_HAS_GETTIMEOFDAY
+
+#include <fcntl.h>
+#include <limits.h>
+#include <sched.h>
+// Declares vsnprintf().  This header is not available on Windows.
+#include <strings.h>
+#include <sys/mman.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <string>
+#include <vector>
+
+#elif defined(_WIN32_WCE)  // We are on Windows CE.
+
+#include <windows.h>  // NOLINT
+
+#elif defined(_WIN32)  // We are on Windows proper.
+
+#include <io.h>  // NOLINT
+#include <sys/timeb.h>  // NOLINT
+#include <sys/types.h>  // NOLINT
+#include <sys/stat.h>  // NOLINT
+
+#if defined(__MINGW__) || defined(__MINGW32__)
+// MinGW has gettimeofday() but not _ftime64().
+// TODO(kenton@google.com): Use autoconf to detect availability of
+//   gettimeofday().
+// TODO(kenton@google.com): There are other ways to get the time on
+//   Windows, like GetTickCount() or GetSystemTimeAsFileTime().  MinGW
+//   supports these.  consider using them instead.
+#define GTEST_HAS_GETTIMEOFDAY
+#include <sys/time.h>  // NOLINT
+#endif
+
+// cpplint thinks that the header is already included, so we want to
+// silence it.
+#include <windows.h>  // NOLINT
+
+#else
+
+// Assume other platforms have gettimeofday().
+// TODO(kenton@google.com): Use autoconf to detect availability of
+//   gettimeofday().
+#define GTEST_HAS_GETTIMEOFDAY
+
+// cpplint thinks that the header is already included, so we want to
+// silence it.
+#include <sys/time.h>  // NOLINT
+#include <unistd.h>  // NOLINT
+
+#endif
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick is to
+// prevent a user from accidentally including gtest-internal-inl.h in
+// his code.
+#define GTEST_IMPLEMENTATION
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION
+
+#ifdef GTEST_OS_WINDOWS
+#define fileno _fileno
+#define isatty _isatty
+#define vsnprintf _vsnprintf
+#endif  // GTEST_OS_WINDOWS
+
+namespace testing {
+
+// Constants.
+
+// A test that matches this pattern is disabled and not run.
+static const char kDisableTestPattern[] = "DISABLED_*";
+
+// A test filter that matches everything.
+static const char kUniversalFilter[] = "*";
+
+// The default output file for XML output.
+static const char kDefaultOutputFile[] = "test_detail.xml";
+
+GTEST_DEFINE_bool(
+    break_on_failure,
+    internal::BoolFromGTestEnv("break_on_failure", false),
+    "True iff a failed assertion should be a debugger break-point.");
+
+GTEST_DEFINE_bool(
+    catch_exceptions,
+    internal::BoolFromGTestEnv("catch_exceptions", false),
+    "True iff " GTEST_NAME
+    " should catch exceptions and treat them as test failures.");
+
+GTEST_DEFINE_string(
+    color,
+    internal::StringFromGTestEnv("color", "auto"),
+    "Whether to use colors in the output.  Valid values: yes, no, "
+    "and auto.  'auto' means to use colors if the output is "
+    "being sent to a terminal and the TERM environment variable "
+    "is set to xterm or xterm-color.");
+
+GTEST_DEFINE_string(
+    filter,
+    internal::StringFromGTestEnv("filter", kUniversalFilter),
+    "A colon-separated list of glob (not regex) patterns "
+    "for filtering the tests to run, optionally followed by a "
+    "'-' and a : separated list of negative patterns (tests to "
+    "exclude).  A test is run if it matches one of the positive "
+    "patterns and does not match any of the negative patterns.");
+
+GTEST_DEFINE_bool(list_tests, false,
+                  "List all tests without running them.");
+
+GTEST_DEFINE_string(
+    output,
+    internal::StringFromGTestEnv("output", ""),
+    "A format (currently must be \"xml\"), optionally followed "
+    "by a colon and an output file name or directory. A directory "
+    "is indicated by a trailing pathname separator. "
+    "Examples: \"xml:filename.xml\", \"xml::directoryname/\". "
+    "If a directory is specified, output files will be created "
+    "within that directory, with file-names based on the test "
+    "executable's name and, if necessary, made unique by adding "
+    "digits.");
+
+GTEST_DEFINE_int32(
+    repeat,
+    internal::Int32FromGTestEnv("repeat", 1),
+    "How many times to repeat each test.  Specify a negative number "
+    "for repeating forever.  Useful for shaking out flaky tests.");
+
+GTEST_DEFINE_int32(
+    stack_trace_depth,
+        internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),
+    "The maximum number of stack frames to print when an "
+    "assertion fails.  The valid range is 0 through 100, inclusive.");
+
+GTEST_DEFINE_bool(
+    show_internal_stack_frames, false,
+    "True iff " GTEST_NAME " should include internal stack frames when "
+    "printing test failure stack traces.");
+
+namespace internal {
+
+// GTestIsInitialized() returns true iff the user has initialized
+// Google Test.  Useful for catching the user mistake of not initializing
+// Google Test before calling RUN_ALL_TESTS().
+
+// A user must call testing::InitGoogleTest() to initialize Google
+// Test.  g_parse_gtest_flags_called is set to true iff
+// InitGoogleTest() has been called.  We don't protect this variable
+// under a mutex as it is only accessed in the main thread.
+static bool g_parse_gtest_flags_called = false;
+static bool GTestIsInitialized() { return g_parse_gtest_flags_called; }
+
+// Iterates over a list of TestCases, keeping a running sum of the
+// results of calling a given int-returning method on each.
+// Returns the sum.
+static int SumOverTestCaseList(const internal::List<TestCase*>& case_list,
+                               int (TestCase::*method)() const) {
+  int sum = 0;
+  for (const internal::ListNode<TestCase*>* node = case_list.Head();
+       node != NULL;
+       node = node->next()) {
+    sum += (node->element()->*method)();
+  }
+  return sum;
+}
+
+// Returns true iff the test case passed.
+static bool TestCasePassed(const TestCase* test_case) {
+  return test_case->should_run() && test_case->Passed();
+}
+
+// Returns true iff the test case failed.
+static bool TestCaseFailed(const TestCase* test_case) {
+  return test_case->should_run() && test_case->Failed();
+}
+
+// Returns true iff test_case contains at least one test that should
+// run.
+static bool ShouldRunTestCase(const TestCase* test_case) {
+  return test_case->should_run();
+}
+
+#ifdef _WIN32_WCE
+// Windows CE has no C library. The abort() function is used in
+// several places in Google Test. This implementation provides a reasonable
+// imitation of standard behaviour.
+static void abort() {
+  DebugBreak();
+  TerminateProcess(GetCurrentProcess(), 1);
+}
+#endif  // _WIN32_WCE
+
+// AssertHelper constructor.
+AssertHelper::AssertHelper(TestPartResultType type, const char* file,
+                           int line, const char* message)
+    : type_(type), file_(file), line_(line), message_(message) {
+}
+
+// Message assignment, for assertion streaming support.
+void AssertHelper::operator=(const Message& message) const {
+  UnitTest::GetInstance()->
+    AddTestPartResult(type_, file_, line_,
+                      AppendUserMessage(message_, message),
+                      UnitTest::GetInstance()->impl()
+                      ->CurrentOsStackTraceExceptTop(1)
+                      // Skips the stack frame for this function itself.
+                      );  // NOLINT
+}
+
+// Application pathname gotten in InitGoogleTest.
+String g_executable_path;
+
+// Returns the current application's name, removing directory path if that
+// is present.
+FilePath GetCurrentExecutableName() {
+  FilePath result;
+
+#if defined(_WIN32_WCE) || defined(_WIN32)
+  result.Set(FilePath(g_executable_path).RemoveExtension("exe"));
+#else
+  result.Set(FilePath(g_executable_path));
+#endif  // _WIN32_WCE || _WIN32
+
+  return result.RemoveDirectoryName();
+}
+
+// Functions for processing the gtest_output flag.
+
+// Returns the output format, or "" for normal printed output.
+String UnitTestOptions::GetOutputFormat() {
+  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
+  if (gtest_output_flag == NULL) return String("");
+
+  const char* const colon = strchr(gtest_output_flag, ':');
+  return (colon == NULL) ?
+      String(gtest_output_flag) :
+      String(gtest_output_flag, colon - gtest_output_flag);
+}
+
+// Returns the name of the requested output file, or the default if none
+// was explicitly specified.
+String UnitTestOptions::GetOutputFile() {
+  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
+  if (gtest_output_flag == NULL)
+    return String("");
+
+  const char* const colon = strchr(gtest_output_flag, ':');
+  if (colon == NULL)
+    return String(kDefaultOutputFile);
+
+  internal::FilePath output_name(colon + 1);
+  if (!output_name.IsDirectory())
+    return output_name.ToString();
+
+  internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
+      output_name, internal::GetCurrentExecutableName(),
+      GetOutputFormat().c_str()));
+  return result.ToString();
+}
+
+// Returns true iff the wildcard pattern matches the string.  The
+// first ':' or '\0' character in pattern marks the end of it.
+//
+// This recursive algorithm isn't very efficient, but is clear and
+// works well enough for matching test names, which are short.
+bool UnitTestOptions::PatternMatchesString(const char *pattern,
+                                           const char *str) {
+  switch (*pattern) {
+    case '\0':
+    case ':':  // Either ':' or '\0' marks the end of the pattern.
+      return *str == '\0';
+    case '?':  // Matches any single character.
+      return *str != '\0' && PatternMatchesString(pattern + 1, str + 1);
+    case '*':  // Matches any string (possibly empty) of characters.
+      return (*str != '\0' && PatternMatchesString(pattern, str + 1)) ||
+          PatternMatchesString(pattern + 1, str);
+    default:  // Non-special character.  Matches itself.
+      return *pattern == *str &&
+          PatternMatchesString(pattern + 1, str + 1);
+  }
+}
+
+bool UnitTestOptions::MatchesFilter(const String& name, const char* filter) {
+  const char *cur_pattern = filter;
+  while (true) {
+    if (PatternMatchesString(cur_pattern, name.c_str())) {
+      return true;
+    }
+
+    // Finds the next pattern in the filter.
+    cur_pattern = strchr(cur_pattern, ':');
+
+    // Returns if no more pattern can be found.
+    if (cur_pattern == NULL) {
+      return false;
+    }
+
+    // Skips the pattern separater (the ':' character).
+    cur_pattern++;
+  }
+}
+
+// TODO(keithray): move String function implementations to gtest-string.cc.
+
+// Returns true iff the user-specified filter matches the test case
+// name and the test name.
+bool UnitTestOptions::FilterMatchesTest(const String &test_case_name,
+                                        const String &test_name) {
+  const String& full_name = String::Format("%s.%s",
+                                           test_case_name.c_str(),
+                                           test_name.c_str());
+
+  // Split --gtest_filter at '-', if there is one, to separate into
+  // positive filter and negative filter portions
+  const char* const p = GTEST_FLAG(filter).c_str();
+  const char* const dash = strchr(p, '-');
+  String positive;
+  String negative;
+  if (dash == NULL) {
+    positive = GTEST_FLAG(filter).c_str();  // Whole string is a positive filter
+    negative = String("");
+  } else {
+    positive.Set(p, dash - p);       // Everything up to the dash
+    negative = String(dash+1);       // Everything after the dash
+    if (positive.empty()) {
+      // Treat '-test1' as the same as '*-test1'
+      positive = kUniversalFilter;
+    }
+  }
+
+  // A filter is a colon-separated list of patterns.  It matches a
+  // test if any pattern in it matches the test.
+  return (MatchesFilter(full_name, positive.c_str()) &&
+          !MatchesFilter(full_name, negative.c_str()));
+}
+
+#ifdef GTEST_OS_WINDOWS
+// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
+// given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
+// This function is useful as an __except condition.
+int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {
+  // Google Test should handle an exception if:
+  //   1. the user wants it to, AND
+  //   2. this is not a breakpoint exception.
+  return (GTEST_FLAG(catch_exceptions) &&
+          exception_code != EXCEPTION_BREAKPOINT) ?
+      EXCEPTION_EXECUTE_HANDLER :
+      EXCEPTION_CONTINUE_SEARCH;
+}
+#endif  // GTEST_OS_WINDOWS
+
+}  // namespace internal
+
+// The interface for printing the result of a UnitTest
+class UnitTestEventListenerInterface {
+ public:
+  // The d'tor is pure virtual as this is an abstract class.
+  virtual ~UnitTestEventListenerInterface() = 0;
+
+  // Called before the unit test starts.
+  virtual void OnUnitTestStart(const UnitTest*) {}
+
+  // Called after the unit test ends.
+  virtual void OnUnitTestEnd(const UnitTest*) {}
+
+  // Called before the test case starts.
+  virtual void OnTestCaseStart(const TestCase*) {}
+
+  // Called after the test case ends.
+  virtual void OnTestCaseEnd(const TestCase*) {}
+
+  // Called before the global set-up starts.
+  virtual void OnGlobalSetUpStart(const UnitTest*) {}
+
+  // Called after the global set-up ends.
+  virtual void OnGlobalSetUpEnd(const UnitTest*) {}
+
+  // Called before the global tear-down starts.
+  virtual void OnGlobalTearDownStart(const UnitTest*) {}
+
+  // Called after the global tear-down ends.
+  virtual void OnGlobalTearDownEnd(const UnitTest*) {}
+
+  // Called before the test starts.
+  virtual void OnTestStart(const TestInfo*) {}
+
+  // Called after the test ends.
+  virtual void OnTestEnd(const TestInfo*) {}
+
+  // Called after an assertion.
+  virtual void OnNewTestPartResult(const TestPartResult*) {}
+};
+
+// Constructs an empty TestPartResultArray.
+TestPartResultArray::TestPartResultArray()
+    : list_(new internal::List<TestPartResult>) {
+}
+
+// Destructs a TestPartResultArray.
+TestPartResultArray::~TestPartResultArray() {
+  delete list_;
+}
+
+// Appends a TestPartResult to the array.
+void TestPartResultArray::Append(const TestPartResult& result) {
+  list_->PushBack(result);
+}
+
+// Returns the TestPartResult at the given index (0-based).
+const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
+  if (index < 0 || index >= size()) {
+    printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
+    abort();
+  }
+
+  const internal::ListNode<TestPartResult>* p = list_->Head();
+  for (int i = 0; i < index; i++) {
+    p = p->next();
+  }
+
+  return p->element();
+}
+
+// Returns the number of TestPartResult objects in the array.
+int TestPartResultArray::size() const {
+  return list_->size();
+}
+
+// The c'tor sets this object as the test part result reporter used by
+// Google Test.  The 'result' parameter specifies where to report the
+// results.
+ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
+    TestPartResultArray* result)
+    : old_reporter_(UnitTest::GetInstance()->impl()->
+                    test_part_result_reporter()),
+      result_(result) {
+  internal::UnitTestImpl* const impl = UnitTest::GetInstance()->impl();
+  impl->set_test_part_result_reporter(this);
+}
+
+// The d'tor restores the test part result reporter used by Google Test
+// before.
+ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
+  UnitTest::GetInstance()->impl()->
+      set_test_part_result_reporter(old_reporter_);
+}
+
+// Increments the test part result count and remembers the result.
+// This method is from the TestPartResultReporterInterface interface.
+void ScopedFakeTestPartResultReporter::ReportTestPartResult(
+    const TestPartResult& result) {
+  result_->Append(result);
+}
+
+namespace internal {
+
+// This predicate-formatter checks that 'results' contains a test part
+// failure of the given type and that the failure message contains the
+// given substring.
+AssertionResult HasOneFailure(const char* /* results_expr */,
+                              const char* /* type_expr */,
+                              const char* /* substr_expr */,
+                              const TestPartResultArray& results,
+                              TestPartResultType type,
+                              const char* substr) {
+  const String expected(
+      type == TPRT_FATAL_FAILURE ? "1 fatal failure" :
+      "1 non-fatal failure");
+  Message msg;
+  if (results.size() != 1) {
+    msg << "Expected: " << expected << "\n"
+        << "  Actual: " << results.size() << " failures";
+    for (int i = 0; i < results.size(); i++) {
+      msg << "\n" << results.GetTestPartResult(i);
+    }
+    return AssertionFailure(msg);
+  }
+
+  const TestPartResult& r = results.GetTestPartResult(0);
+  if (r.type() != type) {
+    msg << "Expected: " << expected << "\n"
+        << "  Actual:\n"
+        << r;
+    return AssertionFailure(msg);
+  }
+
+  if (strstr(r.message(), substr) == NULL) {
+    msg << "Expected: " << expected << " containing \""
+        << substr << "\"\n"
+        << "  Actual:\n"
+        << r;
+    return AssertionFailure(msg);
+  }
+
+  return AssertionSuccess();
+}
+
+// The constructor of SingleFailureChecker remembers where to look up
+// test part results, what type of failure we expect, and what
+// substring the failure message should contain.
+SingleFailureChecker:: SingleFailureChecker(
+    const TestPartResultArray* results,
+    TestPartResultType type,
+    const char* substr)
+    : results_(results),
+      type_(type),
+      substr_(substr) {}
+
+// The destructor of SingleFailureChecker verifies that the given
+// TestPartResultArray contains exactly one failure that has the given
+// type and contains the given substring.  If that's not the case, a
+// non-fatal failure will be generated.
+SingleFailureChecker::~SingleFailureChecker() {
+  EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_.c_str());
+}
+
+// Reports a test part result.
+void UnitTestImpl::ReportTestPartResult(const TestPartResult& result) {
+  current_test_result()->AddTestPartResult(result);
+  result_printer()->OnNewTestPartResult(&result);
+}
+
+// Returns the current test part result reporter.
+TestPartResultReporterInterface* UnitTestImpl::test_part_result_reporter() {
+  return test_part_result_reporter_;
+}
+
+// Sets the current test part result reporter.
+void UnitTestImpl::set_test_part_result_reporter(
+    TestPartResultReporterInterface* reporter) {
+  test_part_result_reporter_ = reporter;
+}
+
+// Gets the number of successful test cases.
+int UnitTestImpl::successful_test_case_count() const {
+  return test_cases_.CountIf(TestCasePassed);
+}
+
+// Gets the number of failed test cases.
+int UnitTestImpl::failed_test_case_count() const {
+  return test_cases_.CountIf(TestCaseFailed);
+}
+
+// Gets the number of all test cases.
+int UnitTestImpl::total_test_case_count() const {
+  return test_cases_.size();
+}
+
+// Gets the number of all test cases that contain at least one test
+// that should run.
+int UnitTestImpl::test_case_to_run_count() const {
+  return test_cases_.CountIf(ShouldRunTestCase);
+}
+
+// Gets the number of successful tests.
+int UnitTestImpl::successful_test_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::successful_test_count);
+}
+
+// Gets the number of failed tests.
+int UnitTestImpl::failed_test_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::failed_test_count);
+}
+
+// Gets the number of disabled tests.
+int UnitTestImpl::disabled_test_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count);
+}
+
+// Gets the number of all tests.
+int UnitTestImpl::total_test_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::total_test_count);
+}
+
+// Gets the number of tests that should run.
+int UnitTestImpl::test_to_run_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::test_to_run_count);
+}
+
+// Returns the current OS stack trace as a String.
+//
+// The maximum number of stack frames to be included is specified by
+// the gtest_stack_trace_depth flag.  The skip_count parameter
+// specifies the number of top frames to be skipped, which doesn't
+// count against the number of frames to be included.
+//
+// For example, if Foo() calls Bar(), which in turn calls
+// CurrentOsStackTraceExceptTop(1), Foo() will be included in the
+// trace but Bar() and CurrentOsStackTraceExceptTop() won't.
+String UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
+  (void)skip_count;
+  return String("");
+}
+
+static TimeInMillis GetTimeInMillis() {
+#ifdef _WIN32_WCE  // We are on Windows CE
+  // Difference between 1970-01-01 and 1601-01-01 in miliseconds.
+  // http://analogous.blogspot.com/2005/04/epoch.html
+  const TimeInMillis kJavaEpochToWinFileTimeDelta = 11644473600000UL;
+  const DWORD kTenthMicrosInMilliSecond = 10000;
+
+  SYSTEMTIME now_systime;
+  FILETIME now_filetime;
+  ULARGE_INTEGER now_int64;
+  // TODO(kenton@google.com): Shouldn't this just use
+  //   GetSystemTimeAsFileTime()?
+  GetSystemTime(&now_systime);
+  if (SystemTimeToFileTime(&now_systime, &now_filetime)) {
+    now_int64.LowPart = now_filetime.dwLowDateTime;
+    now_int64.HighPart = now_filetime.dwHighDateTime;
+    now_int64.QuadPart = (now_int64.QuadPart / kTenthMicrosInMilliSecond) -
+      kJavaEpochToWinFileTimeDelta;
+    return now_int64.QuadPart;
+  }
+  return 0;
+#elif defined(_WIN32) && !defined(GTEST_HAS_GETTIMEOFDAY)
+  __timeb64 now;
+#ifdef _MSC_VER
+  // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996
+  // (deprecated function) there.
+  // TODO(kenton@google.com): Use GetTickCount()?  Or use
+  //   SystemTimeToFileTime()
+#pragma warning(push)          // Saves the current warning state.
+#pragma warning(disable:4996)  // Temporarily disables warning 4996.
+  _ftime64(&now);
+#pragma warning(pop)           // Restores the warning state.
+#else
+  _ftime64(&now);
+#endif  // _MSC_VER
+  return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm;
+#elif defined(GTEST_HAS_GETTIMEOFDAY)
+  struct timeval now;
+  gettimeofday(&now, NULL);
+  return static_cast<TimeInMillis>(now.tv_sec) * 1000 + now.tv_usec / 1000;
+#else
+#error "Don't know how to get the current time on your system."
+#endif
+}
+
+// Utilities
+
+// class String
+
+// Returns the input enclosed in double quotes if it's not NULL;
+// otherwise returns "(null)".  For example, "\"Hello\"" is returned
+// for input "Hello".
+//
+// This is useful for printing a C string in the syntax of a literal.
+//
+// Known issue: escape sequences are not handled yet.
+String String::ShowCStringQuoted(const char* c_str) {
+  return c_str ? String::Format("\"%s\"", c_str) : String("(null)");
+}
+
+// Copies at most length characters from str into a newly-allocated
+// piece of memory of size length+1.  The memory is allocated with new[].
+// A terminating null byte is written to the memory, and a pointer to it
+// is returned.  If str is NULL, NULL is returned.
+static char* CloneString(const char* str, size_t length) {
+  if (str == NULL) {
+    return NULL;
+  } else {
+    char* const clone = new char[length + 1];
+    // MSVC 8 deprecates strncpy(), so we want to suppress warning
+    // 4996 (deprecated function) there.
+#ifdef GTEST_OS_WINDOWS  // We are on Windows.
+#pragma warning(push)          // Saves the current warning state.
+#pragma warning(disable:4996)  // Temporarily disables warning 4996.
+    strncpy(clone, str, length);
+#pragma warning(pop)           // Restores the warning state.
+#else  // We are on Linux or Mac OS.
+    strncpy(clone, str, length);
+#endif  // GTEST_OS_WINDOWS
+    clone[length] = '\0';
+    return clone;
+  }
+}
+
+// Clones a 0-terminated C string, allocating memory using new.  The
+// caller is responsible for deleting[] the return value.  Returns the
+// cloned string, or NULL if the input is NULL.
+const char * String::CloneCString(const char* c_str) {
+  return (c_str == NULL) ?
+                    NULL : CloneString(c_str, strlen(c_str));
+}
+
+// Compares two C strings.  Returns true iff they have the same content.
+//
+// Unlike strcmp(), this function can handle NULL argument(s).  A NULL
+// C string is considered different to any non-NULL C string,
+// including the empty string.
+bool String::CStringEquals(const char * lhs, const char * rhs) {
+  if ( lhs == NULL ) return rhs == NULL;
+
+  if ( rhs == NULL ) return false;
+
+  return strcmp(lhs, rhs) == 0;
+}
+
+#if GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
+
+// Converts an array of wide chars to a narrow string using the UTF-8
+// encoding, and streams the result to the given Message object.
+static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len,
+                                     Message* msg) {
+  for (size_t i = 0; i != len; i++) {
+    // TODO(wan): consider allowing a testing::String object to
+    // contain '\0'.  This will make it behave more like std::string,
+    // and will allow ToUtf8String() to return the correct encoding
+    // for '\0' s.t. we can get rid of the conditional here (and in
+    // several other places).
+    if (wstr[i]) {
+      *msg << internal::ToUtf8String(wstr[i]);
+    } else {
+      *msg << '\0';
+    }
+  }
+}
+
+#endif  // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
+
+}  // namespace internal
+
+#if GTEST_HAS_STD_WSTRING
+// Converts the given wide string to a narrow string using the UTF-8
+// encoding, and streams the result to this Message object.
+Message& Message::operator <<(const ::std::wstring& wstr) {
+  internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
+  return *this;
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+#if GTEST_HAS_GLOBAL_WSTRING
+// Converts the given wide string to a narrow string using the UTF-8
+// encoding, and streams the result to this Message object.
+Message& Message::operator <<(const ::wstring& wstr) {
+  internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
+  return *this;
+}
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+namespace internal {
+
+// Formats a value to be used in a failure message.
+
+// For a char value, we print it as a C++ char literal and as an
+// unsigned integer (both in decimal and in hexadecimal).
+String FormatForFailureMessage(char ch) {
+  const unsigned int ch_as_uint = ch;
+  // A String object cannot contain '\0', so we print "\\0" when ch is
+  // '\0'.
+  return String::Format("'%s' (%u, 0x%X)",
+                        ch ? String::Format("%c", ch).c_str() : "\\0",
+                        ch_as_uint, ch_as_uint);
+}
+
+// For a wchar_t value, we print it as a C++ wchar_t literal and as an
+// unsigned integer (both in decimal and in hexidecimal).
+String FormatForFailureMessage(wchar_t wchar) {
+  // The C++ standard doesn't specify the exact size of the wchar_t
+  // type.  It just says that it shall have the same size as another
+  // integral type, called its underlying type.
+  //
+  // Therefore, in order to print a wchar_t value in the numeric form,
+  // we first convert it to the largest integral type (UInt64) and
+  // then print the converted value.
+  //
+  // We use streaming to print the value as "%llu" doesn't work
+  // correctly with MSVC 7.1.
+  const UInt64 wchar_as_uint64 = wchar;
+  Message msg;
+  // A String object cannot contain '\0', so we print "\\0" when wchar is
+  // L'\0'.
+  msg << "L'" << (wchar ? ToUtf8String(wchar).c_str() : "\\0") << "' ("
+      << wchar_as_uint64 << ", 0x" << ::std::setbase(16)
+      << wchar_as_uint64 << ")";
+  return msg.GetString();
+}
+
+}  // namespace internal
+
+// AssertionResult constructor.
+AssertionResult::AssertionResult(const internal::String& failure_message)
+    : failure_message_(failure_message) {
+}
+
+
+// Makes a successful assertion result.
+AssertionResult AssertionSuccess() {
+  return AssertionResult();
+}
+
+
+// Makes a failed assertion result with the given failure message.
+AssertionResult AssertionFailure(const Message& message) {
+  return AssertionResult(message.GetString());
+}
+
+namespace internal {
+
+// Constructs and returns the message for an equality assertion
+// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
+//
+// The first four parameters are the expressions used in the assertion
+// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
+// where foo is 5 and bar is 6, we have:
+//
+//   expected_expression: "foo"
+//   actual_expression:   "bar"
+//   expected_value:      "5"
+//   actual_value:        "6"
+//
+// The ignoring_case parameter is true iff the assertion is a
+// *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will
+// be inserted into the message.
+AssertionResult EqFailure(const char* expected_expression,
+                          const char* actual_expression,
+                          const String& expected_value,
+                          const String& actual_value,
+                          bool ignoring_case) {
+  Message msg;
+  msg << "Value of: " << actual_expression;
+  if (actual_value != actual_expression) {
+    msg << "\n  Actual: " << actual_value;
+  }
+
+  msg << "\nExpected: " << expected_expression;
+  if (ignoring_case) {
+    msg << " (ignoring case)";
+  }
+  if (expected_value != expected_expression) {
+    msg << "\nWhich is: " << expected_value;
+  }
+
+  return AssertionFailure(msg);
+}
+
+
+// Helper function for implementing ASSERT_NEAR.
+AssertionResult DoubleNearPredFormat(const char* expr1,
+                                     const char* expr2,
+                                     const char* abs_error_expr,
+                                     double val1,
+                                     double val2,
+                                     double abs_error) {
+  const double diff = fabs(val1 - val2);
+  if (diff <= abs_error) return AssertionSuccess();
+
+  // TODO(wan): do not print the value of an expression if it's
+  // already a literal.
+  Message msg;
+  msg << "The difference between " << expr1 << " and " << expr2
+      << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"
+      << expr1 << " evaluates to " << val1 << ",\n"
+      << expr2 << " evaluates to " << val2 << ", and\n"
+      << abs_error_expr << " evaluates to " << abs_error << ".";
+  return AssertionFailure(msg);
+}
+
+
+// Helper template for implementing FloatLE() and DoubleLE().
+template <typename RawType>
+AssertionResult FloatingPointLE(const char* expr1,
+                                const char* expr2,
+                                RawType val1,
+                                RawType val2) {
+  // Returns success if val1 is less than val2,
+  if (val1 < val2) {
+    return AssertionSuccess();
+  }
+
+  // or if val1 is almost equal to val2.
+  const FloatingPoint<RawType> lhs(val1), rhs(val2);
+  if (lhs.AlmostEquals(rhs)) {
+    return AssertionSuccess();
+  }
+
+  // Note that the above two checks will both fail if either val1 or
+  // val2 is NaN, as the IEEE floating-point standard requires that
+  // any predicate involving a NaN must return false.
+
+  StrStream val1_ss;
+  val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+          << val1;
+
+  StrStream val2_ss;
+  val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+          << val2;
+
+  Message msg;
+  msg << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"
+      << "  Actual: " << StrStreamToString(&val1_ss) << " vs "
+      << StrStreamToString(&val2_ss);
+
+  return AssertionFailure(msg);
+}
+
+}  // namespace internal
+
+// Asserts that val1 is less than, or almost equal to, val2.  Fails
+// otherwise.  In particular, it fails if either val1 or val2 is NaN.
+AssertionResult FloatLE(const char* expr1, const char* expr2,
+                        float val1, float val2) {
+  return internal::FloatingPointLE<float>(expr1, expr2, val1, val2);
+}
+
+// Asserts that val1 is less than, or almost equal to, val2.  Fails
+// otherwise.  In particular, it fails if either val1 or val2 is NaN.
+AssertionResult DoubleLE(const char* expr1, const char* expr2,
+                         double val1, double val2) {
+  return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);
+}
+
+namespace internal {
+
+// The helper function for {ASSERT|EXPECT}_EQ with int or enum
+// arguments.
+AssertionResult CmpHelperEQ(const char* expected_expression,
+                            const char* actual_expression,
+                            BiggestInt expected,
+                            BiggestInt actual) {
+  if (expected == actual) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(expected_expression,
+                   actual_expression,
+                   FormatForComparisonFailureMessage(expected, actual),
+                   FormatForComparisonFailureMessage(actual, expected),
+                   false);
+}
+
+// A macro for implementing the helper functions needed to implement
+// ASSERT_?? and EXPECT_?? with integer or enum arguments.  It is here
+// just to avoid copy-and-paste of similar code.
+#define GTEST_IMPL_CMP_HELPER(op_name, op)\
+AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
+                                   BiggestInt val1, BiggestInt val2) {\
+  if (val1 op val2) {\
+    return AssertionSuccess();\
+  } else {\
+    Message msg;\
+    msg << "Expected: (" << expr1 << ") " #op " (" << expr2\
+        << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
+        << " vs " << FormatForComparisonFailureMessage(val2, val1);\
+    return AssertionFailure(msg);\
+  }\
+}
+
+// Implements the helper function for {ASSERT|EXPECT}_NE with int or
+// enum arguments.
+GTEST_IMPL_CMP_HELPER(NE, !=)
+// Implements the helper function for {ASSERT|EXPECT}_LE with int or
+// enum arguments.
+GTEST_IMPL_CMP_HELPER(LE, <=)
+// Implements the helper function for {ASSERT|EXPECT}_LT with int or
+// enum arguments.
+GTEST_IMPL_CMP_HELPER(LT, < )
+// Implements the helper function for {ASSERT|EXPECT}_GE with int or
+// enum arguments.
+GTEST_IMPL_CMP_HELPER(GE, >=)
+// Implements the helper function for {ASSERT|EXPECT}_GT with int or
+// enum arguments.
+GTEST_IMPL_CMP_HELPER(GT, > )
+
+#undef GTEST_IMPL_CMP_HELPER
+
+// The helper function for {ASSERT|EXPECT}_STREQ.
+AssertionResult CmpHelperSTREQ(const char* expected_expression,
+                               const char* actual_expression,
+                               const char* expected,
+                               const char* actual) {
+  if (String::CStringEquals(expected, actual)) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(expected_expression,
+                   actual_expression,
+                   String::ShowCStringQuoted(expected),
+                   String::ShowCStringQuoted(actual),
+                   false);
+}
+
+// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
+AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression,
+                                   const char* actual_expression,
+                                   const char* expected,
+                                   const char* actual) {
+  if (String::CaseInsensitiveCStringEquals(expected, actual)) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(expected_expression,
+                   actual_expression,
+                   String::ShowCStringQuoted(expected),
+                   String::ShowCStringQuoted(actual),
+                   true);
+}
+
+// The helper function for {ASSERT|EXPECT}_STRNE.
+AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                               const char* s2_expression,
+                               const char* s1,
+                               const char* s2) {
+  if (!String::CStringEquals(s1, s2)) {
+    return AssertionSuccess();
+  } else {
+    Message msg;
+    msg << "Expected: (" << s1_expression << ") != ("
+        << s2_expression << "), actual: \""
+        << s1 << "\" vs \"" << s2 << "\"";
+    return AssertionFailure(msg);
+  }
+}
+
+// The helper function for {ASSERT|EXPECT}_STRCASENE.
+AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
+                                   const char* s2_expression,
+                                   const char* s1,
+                                   const char* s2) {
+  if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
+    return AssertionSuccess();
+  } else {
+    Message msg;
+    msg << "Expected: (" << s1_expression << ") != ("
+        << s2_expression << ") (ignoring case), actual: \""
+        << s1 << "\" vs \"" << s2 << "\"";
+    return AssertionFailure(msg);
+  }
+}
+
+}  // namespace internal
+
+namespace {
+
+// Helper functions for implementing IsSubString() and IsNotSubstring().
+
+// This group of overloaded functions return true iff needle is a
+// substring of haystack.  NULL is considered a substring of itself
+// only.
+
+bool IsSubstringPred(const char* needle, const char* haystack) {
+  if (needle == NULL || haystack == NULL)
+    return needle == haystack;
+
+  return strstr(haystack, needle) != NULL;
+}
+
+bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
+  if (needle == NULL || haystack == NULL)
+    return needle == haystack;
+
+  return wcsstr(haystack, needle) != NULL;
+}
+
+// StringType here can be either ::std::string or ::std::wstring.
+template <typename StringType>
+bool IsSubstringPred(const StringType& needle,
+                     const StringType& haystack) {
+  return haystack.find(needle) != StringType::npos;
+}
+
+// This function implements either IsSubstring() or IsNotSubstring(),
+// depending on the value of the expected_to_be_substring parameter.
+// StringType here can be const char*, const wchar_t*, ::std::string,
+// or ::std::wstring.
+template <typename StringType>
+AssertionResult IsSubstringImpl(
+    bool expected_to_be_substring,
+    const char* needle_expr, const char* haystack_expr,
+    const StringType& needle, const StringType& haystack) {
+  if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
+    return AssertionSuccess();
+
+  const bool is_wide_string = sizeof(needle[0]) > 1;
+  const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
+  return AssertionFailure(
+      Message()
+      << "Value of: " << needle_expr << "\n"
+      << "  Actual: " << begin_string_quote << needle << "\"\n"
+      << "Expected: " << (expected_to_be_substring ? "" : "not ")
+      << "a substring of " << haystack_expr << "\n"
+      << "Which is: " << begin_string_quote << haystack << "\"");
+}
+
+}  // namespace
+
+// IsSubstring() and IsNotSubstring() check whether needle is a
+// substring of haystack (NULL is considered a substring of itself
+// only), and return an appropriate error message when they fail.
+
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+
+#if GTEST_HAS_STD_STRING
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+#endif  // GTEST_HAS_STD_STRING
+
+#if GTEST_HAS_STD_WSTRING
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+namespace internal {
+
+#ifdef GTEST_OS_WINDOWS
+
+namespace {
+
+// Helper function for IsHRESULT{SuccessFailure} predicates
+AssertionResult HRESULTFailureHelper(const char* expr,
+                                     const char* expected,
+                                     long hr) {  // NOLINT
+#ifdef _WIN32_WCE
+  // Windows CE doesn't support FormatMessage.
+  const char error_text[] = "";
+#else
+  // Looks up the human-readable system message for the HRESULT code
+  // and since we're not passing any params to FormatMessage, we don't
+  // want inserts expanded.
+  const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM |
+                       FORMAT_MESSAGE_IGNORE_INSERTS;
+  const DWORD kBufSize = 4096;  // String::Format can't exceed this length.
+  // Gets the system's human readable message string for this HRESULT.
+  char error_text[kBufSize] = { '\0' };
+  DWORD message_length = ::FormatMessageA(kFlags,
+                                          0,  // no source, we're asking system
+                                          hr,  // the error
+                                          0,  // no line width restrictions
+                                          error_text,  // output buffer
+                                          kBufSize,  // buf size
+                                          NULL);  // no arguments for inserts
+  // Trims tailing white space (FormatMessage leaves a trailing cr-lf)
+  for (; message_length && isspace(error_text[message_length - 1]);
+          --message_length) {
+    error_text[message_length - 1] = '\0';
+  }
+#endif  // _WIN32_WCE
+
+  const String error_hex(String::Format("0x%08X ", hr));
+  Message msg;
+  msg << "Expected: " << expr << " " << expected << ".\n"
+      << "  Actual: " << error_hex << error_text << "\n";
+
+  return ::testing::AssertionFailure(msg);
+}
+
+}  // namespace
+
+AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
+  if (SUCCEEDED(hr)) {
+    return AssertionSuccess();
+  }
+  return HRESULTFailureHelper(expr, "succeeds", hr);
+}
+
+AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
+  if (FAILED(hr)) {
+    return AssertionSuccess();
+  }
+  return HRESULTFailureHelper(expr, "fails", hr);
+}
+
+#endif  // GTEST_OS_WINDOWS
+
+// Utility functions for encoding Unicode text (wide strings) in
+// UTF-8.
+
+// A Unicode code-point can have upto 21 bits, and is encoded in UTF-8
+// like this:
+//
+// Code-point length   Encoding
+//   0 -  7 bits       0xxxxxxx
+//   8 - 11 bits       110xxxxx 10xxxxxx
+//  12 - 16 bits       1110xxxx 10xxxxxx 10xxxxxx
+//  17 - 21 bits       11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+
+// The maximum code-point a one-byte UTF-8 sequence can represent.
+const UInt32 kMaxCodePoint1 = (static_cast<UInt32>(1) <<  7) - 1;
+
+// The maximum code-point a two-byte UTF-8 sequence can represent.
+const UInt32 kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1;
+
+// The maximum code-point a three-byte UTF-8 sequence can represent.
+const UInt32 kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1;
+
+// The maximum code-point a four-byte UTF-8 sequence can represent.
+const UInt32 kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1;
+
+// Chops off the n lowest bits from a bit pattern.  Returns the n
+// lowest bits.  As a side effect, the original bit pattern will be
+// shifted to the right by n bits.
+inline UInt32 ChopLowBits(UInt32* bits, int n) {
+  const UInt32 low_bits = *bits & ((static_cast<UInt32>(1) << n) - 1);
+  *bits >>= n;
+  return low_bits;
+}
+
+// Converts a Unicode code-point to its UTF-8 encoding.
+String ToUtf8String(wchar_t wchar) {
+  char str[5] = {};  // Initializes str to all '\0' characters.
+
+  UInt32 code = static_cast<UInt32>(wchar);
+  if (code <= kMaxCodePoint1) {
+    str[0] = static_cast<char>(code);                          // 0xxxxxxx
+  } else if (code <= kMaxCodePoint2) {
+    str[1] = static_cast<char>(0x80 | ChopLowBits(&code, 6));  // 10xxxxxx
+    str[0] = static_cast<char>(0xC0 | code);                   // 110xxxxx
+  } else if (code <= kMaxCodePoint3) {
+    str[2] = static_cast<char>(0x80 | ChopLowBits(&code, 6));  // 10xxxxxx
+    str[1] = static_cast<char>(0x80 | ChopLowBits(&code, 6));  // 10xxxxxx
+    str[0] = static_cast<char>(0xE0 | code);                   // 1110xxxx
+  } else if (code <= kMaxCodePoint4) {
+    str[3] = static_cast<char>(0x80 | ChopLowBits(&code, 6));  // 10xxxxxx
+    str[2] = static_cast<char>(0x80 | ChopLowBits(&code, 6));  // 10xxxxxx
+    str[1] = static_cast<char>(0x80 | ChopLowBits(&code, 6));  // 10xxxxxx
+    str[0] = static_cast<char>(0xF0 | code);                   // 11110xxx
+  } else {
+    return String::Format("(Invalid Unicode 0x%llX)",
+                          static_cast<UInt64>(wchar));
+  }
+
+  return String(str);
+}
+
+// Converts a wide C string to a String using the UTF-8 encoding.
+// NULL will be converted to "(null)".
+String String::ShowWideCString(const wchar_t * wide_c_str) {
+  if (wide_c_str == NULL) return String("(null)");
+
+  StrStream ss;
+  while (*wide_c_str) {
+    ss << internal::ToUtf8String(*wide_c_str++);
+  }
+
+  return internal::StrStreamToString(&ss);
+}
+
+// Similar to ShowWideCString(), except that this function encloses
+// the converted string in double quotes.
+String String::ShowWideCStringQuoted(const wchar_t* wide_c_str) {
+  if (wide_c_str == NULL) return String("(null)");
+
+  return String::Format("L\"%s\"",
+                        String::ShowWideCString(wide_c_str).c_str());
+}
+
+// Compares two wide C strings.  Returns true iff they have the same
+// content.
+//
+// Unlike wcscmp(), this function can handle NULL argument(s).  A NULL
+// C string is considered different to any non-NULL C string,
+// including the empty string.
+bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) {
+  if (lhs == NULL) return rhs == NULL;
+
+  if (rhs == NULL) return false;
+
+  return wcscmp(lhs, rhs) == 0;
+}
+
+// Helper function for *_STREQ on wide strings.
+AssertionResult CmpHelperSTREQ(const char* expected_expression,
+                               const char* actual_expression,
+                               const wchar_t* expected,
+                               const wchar_t* actual) {
+  if (String::WideCStringEquals(expected, actual)) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(expected_expression,
+                   actual_expression,
+                   String::ShowWideCStringQuoted(expected),
+                   String::ShowWideCStringQuoted(actual),
+                   false);
+}
+
+// Helper function for *_STRNE on wide strings.
+AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                               const char* s2_expression,
+                               const wchar_t* s1,
+                               const wchar_t* s2) {
+  if (!String::WideCStringEquals(s1, s2)) {
+    return AssertionSuccess();
+  }
+
+  Message msg;
+  msg << "Expected: (" << s1_expression << ") != ("
+      << s2_expression << "), actual: "
+      << String::ShowWideCStringQuoted(s1)
+      << " vs " << String::ShowWideCStringQuoted(s2);
+  return AssertionFailure(msg);
+}
+
+// Compares two C strings, ignoring case.  Returns true iff they have
+// the same content.
+//
+// Unlike strcasecmp(), this function can handle NULL argument(s).  A
+// NULL C string is considered different to any non-NULL C string,
+// including the empty string.
+bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
+  if ( lhs == NULL ) return rhs == NULL;
+
+  if ( rhs == NULL ) return false;
+
+#ifdef GTEST_OS_WINDOWS
+  return _stricmp(lhs, rhs) == 0;
+#else  // GTEST_OS_WINDOWS
+  return strcasecmp(lhs, rhs) == 0;
+#endif  // GTEST_OS_WINDOWS
+}
+
+// Constructs a String by copying a given number of chars from a
+// buffer.  E.g. String("hello", 3) will create the string "hel".
+String::String(const char * buffer, size_t len) {
+  char * const temp = new char[ len + 1 ];
+  memcpy(temp, buffer, len);
+  temp[ len ] = '\0';
+  c_str_ = temp;
+}
+
+// Compares this with another String.
+// Returns < 0 if this is less than rhs, 0 if this is equal to rhs, or > 0
+// if this is greater than rhs.
+int String::Compare(const String & rhs) const {
+  if ( c_str_ == NULL ) {
+    return rhs.c_str_ == NULL ? 0 : -1;  // NULL < anything except NULL
+  }
+
+  return rhs.c_str_ == NULL ? 1 : strcmp(c_str_, rhs.c_str_);
+}
+
+// Returns true iff this String ends with the given suffix.  *Any*
+// String is considered to end with a NULL or empty suffix.
+bool String::EndsWith(const char* suffix) const {
+  if (suffix == NULL || CStringEquals(suffix, "")) return true;
+
+  if (c_str_ == NULL) return false;
+
+  const size_t this_len = strlen(c_str_);
+  const size_t suffix_len = strlen(suffix);
+  return (this_len >= suffix_len) &&
+         CStringEquals(c_str_ + this_len - suffix_len, suffix);
+}
+
+// Returns true iff this String ends with the given suffix, ignoring case.
+// Any String is considered to end with a NULL or empty suffix.
+bool String::EndsWithCaseInsensitive(const char* suffix) const {
+  if (suffix == NULL || CStringEquals(suffix, "")) return true;
+
+  if (c_str_ == NULL) return false;
+
+  const size_t this_len = strlen(c_str_);
+  const size_t suffix_len = strlen(suffix);
+  return (this_len >= suffix_len) &&
+         CaseInsensitiveCStringEquals(c_str_ + this_len - suffix_len, suffix);
+}
+
+// Sets the 0-terminated C string this String object represents.  The
+// old string in this object is deleted, and this object will own a
+// clone of the input string.  This function copies only up to length
+// bytes (plus a terminating null byte), or until the first null byte,
+// whichever comes first.
+//
+// This function works even when the c_str parameter has the same
+// value as that of the c_str_ field.
+void String::Set(const char * c_str, size_t length) {
+  // Makes sure this works when c_str == c_str_
+  const char* const temp = CloneString(c_str, length);
+  delete[] c_str_;
+  c_str_ = temp;
+}
+
+// Assigns a C string to this object.  Self-assignment works.
+const String& String::operator=(const char* c_str) {
+  // Makes sure this works when c_str == c_str_
+  if (c_str != c_str_) {
+    delete[] c_str_;
+    c_str_ = CloneCString(c_str);
+  }
+  return *this;
+}
+
+// Formats a list of arguments to a String, using the same format
+// spec string as for printf.
+//
+// We do not use the StringPrintf class as it is not universally
+// available.
+//
+// The result is limited to 4096 characters (including the tailing 0).
+// If 4096 characters are not enough to format the input,
+// "<buffer exceeded>" is returned.
+String String::Format(const char * format, ...) {
+  va_list args;
+  va_start(args, format);
+
+  char buffer[4096];
+  // MSVC 8 deprecates vsnprintf(), so we want to suppress warning
+  // 4996 (deprecated function) there.
+#ifdef GTEST_OS_WINDOWS  // We are on Windows.
+#pragma warning(push)          // Saves the current warning state.
+#pragma warning(disable:4996)  // Temporarily disables warning 4996.
+  const int size =
+    vsnprintf(buffer, sizeof(buffer)/sizeof(buffer[0]) - 1, format, args);
+#pragma warning(pop)           // Restores the warning state.
+#else  // We are on Linux or Mac OS.
+  const int size =
+    vsnprintf(buffer, sizeof(buffer)/sizeof(buffer[0]) - 1, format, args);
+#endif  // GTEST_OS_WINDOWS
+  va_end(args);
+
+  return String(size >= 0 ? buffer : "<buffer exceeded>");
+}
+
+// Converts the buffer in a StrStream to a String, converting NUL
+// bytes to "\\0" along the way.
+String StrStreamToString(StrStream* ss) {
+#if GTEST_HAS_STD_STRING
+  const ::std::string& str = ss->str();
+  const char* const start = str.c_str();
+  const char* const end = start + str.length();
+#else
+  const char* const start = ss->str();
+  const char* const end = start + ss->pcount();
+#endif  // GTEST_HAS_STD_STRING
+
+  // We need to use a helper StrStream to do this transformation
+  // because String doesn't support push_back().
+  StrStream helper;
+  for (const char* ch = start; ch != end; ++ch) {
+    if (*ch == '\0') {
+      helper << "\\0";  // Replaces NUL with "\\0";
+    } else {
+      helper.put(*ch);
+    }
+  }
+
+#if GTEST_HAS_STD_STRING
+  return String(helper.str().c_str());
+#else
+  const String str(helper.str(), helper.pcount());
+  helper.freeze(false);
+  ss->freeze(false);
+  return str;
+#endif  // GTEST_HAS_STD_STRING
+}
+
+// Appends the user-supplied message to the Google-Test-generated message.
+String AppendUserMessage(const String& gtest_msg,
+                         const Message& user_msg) {
+  // Appends the user message if it's non-empty.
+  const String user_msg_string = user_msg.GetString();
+  if (user_msg_string.empty()) {
+    return gtest_msg;
+  }
+
+  Message msg;
+  msg << gtest_msg << "\n" << user_msg_string;
+
+  return msg.GetString();
+}
+
+}  // namespace internal
+
+// Prints a TestPartResult object.
+std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
+  return os << result.file_name() << ":"
+            << result.line_number() << ": "
+            << (result.type() == TPRT_SUCCESS ? "Success" :
+                result.type() == TPRT_FATAL_FAILURE ? "Fatal failure" :
+                "Non-fatal failure") << ":\n"
+            << result.message() << std::endl;
+}
+
+namespace internal {
+// class TestResult
+
+// Creates an empty TestResult.
+TestResult::TestResult()
+    : death_test_count_(0),
+      elapsed_time_(0) {
+}
+
+// D'tor.
+TestResult::~TestResult() {
+}
+
+// Adds a test part result to the list.
+void TestResult::AddTestPartResult(const TestPartResult& test_part_result) {
+  test_part_results_.PushBack(test_part_result);
+}
+
+// Adds a test property to the list. If a property with the same key as the
+// supplied property is already represented, the value of this test_property
+// replaces the old value for that key.
+void TestResult::RecordProperty(const TestProperty& test_property) {
+  if (!ValidateTestProperty(test_property)) {
+    return;
+  }
+  MutexLock lock(&test_properites_mutex_);
+  ListNode<TestProperty>* const node_with_matching_key =
+      test_properties_.FindIf(TestPropertyKeyIs(test_property.key()));
+  if (node_with_matching_key == NULL) {
+    test_properties_.PushBack(test_property);
+    return;
+  }
+  TestProperty& property_with_matching_key = node_with_matching_key->element();
+  property_with_matching_key.SetValue(test_property.value());
+}
+
+// Adds a failure if the key is a reserved attribute of Google Test testcase tags.
+// Returns true if the property is valid.
+bool TestResult::ValidateTestProperty(const TestProperty& test_property) {
+  String key(test_property.key());
+  if (key == "name" || key == "status" || key == "time" || key == "classname") {
+    ADD_FAILURE()
+        << "Reserved key used in RecordProperty(): "
+        << key
+        << " ('name', 'status', 'time', and 'classname' are reserved by "
+        << GTEST_NAME << ")";
+    return false;
+  }
+  return true;
+}
+
+// Clears the object.
+void TestResult::Clear() {
+  test_part_results_.Clear();
+  test_properties_.Clear();
+  death_test_count_ = 0;
+  elapsed_time_ = 0;
+}
+
+// Returns true iff the test part passed.
+static bool TestPartPassed(const TestPartResult & result) {
+  return result.passed();
+}
+
+// Gets the number of successful test parts.
+int TestResult::successful_part_count() const {
+  return test_part_results_.CountIf(TestPartPassed);
+}
+
+// Returns true iff the test part failed.
+static bool TestPartFailed(const TestPartResult & result) {
+  return result.failed();
+}
+
+// Gets the number of failed test parts.
+int TestResult::failed_part_count() const {
+  return test_part_results_.CountIf(TestPartFailed);
+}
+
+// Returns true iff the test part fatally failed.
+static bool TestPartFatallyFailed(const TestPartResult & result) {
+  return result.fatally_failed();
+}
+
+// Returns true iff the test fatally failed.
+bool TestResult::HasFatalFailure() const {
+  return test_part_results_.CountIf(TestPartFatallyFailed) > 0;
+}
+
+// Gets the number of all test parts.  This is the sum of the number
+// of successful test parts and the number of failed test parts.
+int TestResult::total_part_count() const {
+  return test_part_results_.size();
+}
+
+}  // namespace internal
+
+// class Test
+
+// Creates a Test object.
+
+// The c'tor saves the values of all Google Test flags.
+Test::Test()
+    : gtest_flag_saver_(new internal::GTestFlagSaver) {
+}
+
+// The d'tor restores the values of all Google Test flags.
+Test::~Test() {
+  delete gtest_flag_saver_;
+}
+
+// Sets up the test fixture.
+//
+// A sub-class may override this.
+void Test::SetUp() {
+}
+
+// Tears down the test fixture.
+//
+// A sub-class may override this.
+void Test::TearDown() {
+}
+
+// Allows user supplied key value pairs to be recorded for later output.
+void Test::RecordProperty(const char* key, const char* value) {
+  UnitTest::GetInstance()->RecordPropertyForCurrentTest(key, value);
+}
+
+// Allows user supplied key value pairs to be recorded for later output.
+void Test::RecordProperty(const char* key, int value) {
+  Message value_message;
+  value_message << value;
+  RecordProperty(key, value_message.GetString().c_str());
+}
+
+#ifdef GTEST_OS_WINDOWS
+// We are on Windows.
+
+// Adds an "exception thrown" fatal failure to the current test.
+static void AddExceptionThrownFailure(DWORD exception_code,
+                                      const char* location) {
+  Message message;
+  message << "Exception thrown with code 0x" << std::setbase(16) <<
+    exception_code << std::setbase(10) << " in " << location << ".";
+
+  UnitTest* const unit_test = UnitTest::GetInstance();
+  unit_test->AddTestPartResult(
+      TPRT_FATAL_FAILURE,
+      static_cast<const char *>(NULL),
+           // We have no info about the source file where the exception
+           // occurred.
+      -1,  // We have no info on which line caused the exception.
+      message.GetString(),
+      internal::String(""));
+}
+
+#endif  // GTEST_OS_WINDOWS
+
+// Google Test requires all tests in the same test case to use the same test
+// fixture class.  This function checks if the current test has the
+// same fixture class as the first test in the current test case.  If
+// yes, it returns true; otherwise it generates a Google Test failure and
+// returns false.
+bool Test::HasSameFixtureClass() {
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  const TestCase* const test_case = impl->current_test_case();
+
+  // Info about the first test in the current test case.
+  const internal::TestInfoImpl* const first_test_info =
+      test_case->test_info_list().Head()->element()->impl();
+  const internal::TypeId first_fixture_id = first_test_info->fixture_class_id();
+  const char* const first_test_name = first_test_info->name();
+
+  // Info about the current test.
+  const internal::TestInfoImpl* const this_test_info =
+      impl->current_test_info()->impl();
+  const internal::TypeId this_fixture_id = this_test_info->fixture_class_id();
+  const char* const this_test_name = this_test_info->name();
+
+  if (this_fixture_id != first_fixture_id) {
+    // Is the first test defined using TEST?
+    const bool first_is_TEST = first_fixture_id == internal::GetTypeId<Test>();
+    // Is this test defined using TEST?
+    const bool this_is_TEST = this_fixture_id == internal::GetTypeId<Test>();
+
+    if (first_is_TEST || this_is_TEST) {
+      // The user mixed TEST and TEST_F in this test case - we'll tell
+      // him/her how to fix it.
+
+      // Gets the name of the TEST and the name of the TEST_F.  Note
+      // that first_is_TEST and this_is_TEST cannot both be true, as
+      // the fixture IDs are different for the two tests.
+      const char* const TEST_name =
+          first_is_TEST ? first_test_name : this_test_name;
+      const char* const TEST_F_name =
+          first_is_TEST ? this_test_name : first_test_name;
+
+      ADD_FAILURE()
+          << "All tests in the same test case must use the same test fixture\n"
+          << "class, so mixing TEST_F and TEST in the same test case is\n"
+          << "illegal.  In test case " << this_test_info->test_case_name()
+          << ",\n"
+          << "test " << TEST_F_name << " is defined using TEST_F but\n"
+          << "test " << TEST_name << " is defined using TEST.  You probably\n"
+          << "want to change the TEST to TEST_F or move it to another test\n"
+          << "case.";
+    } else {
+      // The user defined two fixture classes with the same name in
+      // two namespaces - we'll tell him/her how to fix it.
+      ADD_FAILURE()
+          << "All tests in the same test case must use the same test fixture\n"
+          << "class.  However, in test case "
+          << this_test_info->test_case_name() << ",\n"
+          << "you defined test " << first_test_name
+          << " and test " << this_test_name << "\n"
+          << "using two different test fixture classes.  This can happen if\n"
+          << "the two classes are from different namespaces or translation\n"
+          << "units and have the same name.  You should probably rename one\n"
+          << "of the classes to put the tests into different test cases.";
+    }
+    return false;
+  }
+
+  return true;
+}
+
+// Runs the test and updates the test result.
+void Test::Run() {
+  if (!HasSameFixtureClass()) return;
+
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+#ifdef GTEST_OS_WINDOWS
+  // We are on Windows.
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  __try {
+    SetUp();
+  } __except(internal::UnitTestOptions::GTestShouldProcessSEH(
+      GetExceptionCode())) {
+    AddExceptionThrownFailure(GetExceptionCode(), "SetUp()");
+  }
+
+  // We will run the test only if SetUp() had no fatal failure.
+  if (!HasFatalFailure()) {
+    impl->os_stack_trace_getter()->UponLeavingGTest();
+    __try {
+      TestBody();
+    } __except(internal::UnitTestOptions::GTestShouldProcessSEH(
+        GetExceptionCode())) {
+      AddExceptionThrownFailure(GetExceptionCode(), "the test body");
+    }
+  }
+
+  // However, we want to clean up as much as possible.  Hence we will
+  // always call TearDown(), even if SetUp() or the test body has
+  // failed.
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  __try {
+    TearDown();
+  } __except(internal::UnitTestOptions::GTestShouldProcessSEH(
+      GetExceptionCode())) {
+    AddExceptionThrownFailure(GetExceptionCode(), "TearDown()");
+  }
+
+#else  // We are on Linux or Mac - exceptions are disabled.
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  SetUp();
+
+  // We will run the test only if SetUp() was successful.
+  if (!HasFatalFailure()) {
+    impl->os_stack_trace_getter()->UponLeavingGTest();
+    TestBody();
+  }
+
+  // However, we want to clean up as much as possible.  Hence we will
+  // always call TearDown(), even if SetUp() or the test body has
+  // failed.
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  TearDown();
+#endif  // GTEST_OS_WINDOWS
+}
+
+
+// Returns true iff the current test has a fatal failure.
+bool Test::HasFatalFailure() {
+  return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
+}
+
+// class TestInfo
+
+// Constructs a TestInfo object.
+TestInfo::TestInfo(const char* test_case_name,
+                   const char* name,
+                   internal::TypeId fixture_class_id,
+                   TestMaker maker) {
+  impl_ = new internal::TestInfoImpl(this, test_case_name, name,
+                                     fixture_class_id, maker);
+}
+
+// Destructs a TestInfo object.
+TestInfo::~TestInfo() {
+  delete impl_;
+}
+
+// Creates a TestInfo object and registers it with the UnitTest
+// singleton; returns the created object.
+//
+// Arguments:
+//
+//   test_case_name: name of the test case
+//   name:           name of the test
+//   set_up_tc:      pointer to the function that sets up the test case
+//   tear_down_tc:   pointer to the function that tears down the test case
+//   maker:          pointer to the function that creates a test object
+TestInfo* TestInfo::MakeAndRegisterInstance(
+    const char* test_case_name,
+    const char* name,
+    internal::TypeId fixture_class_id,
+    Test::SetUpTestCaseFunc set_up_tc,
+    Test::TearDownTestCaseFunc tear_down_tc,
+    TestMaker maker) {
+  TestInfo* const test_info =
+      new TestInfo(test_case_name, name, fixture_class_id, maker);
+  internal::GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
+  return test_info;
+}
+
+// Returns the test case name.
+const char* TestInfo::test_case_name() const {
+  return impl_->test_case_name();
+}
+
+// Returns the test name.
+const char* TestInfo::name() const {
+  return impl_->name();
+}
+
+// Returns true if this test should run.
+bool TestInfo::should_run() const { return impl_->should_run(); }
+
+// Returns the result of the test.
+const internal::TestResult* TestInfo::result() const { return impl_->result(); }
+
+// Increments the number of death tests encountered in this test so
+// far.
+int TestInfo::increment_death_test_count() {
+  return impl_->result()->increment_death_test_count();
+}
+
+namespace {
+
+// A predicate that checks the test name of a TestInfo against a known
+// value.
+//
+// This is used for implementation of the TestCase class only.  We put
+// it in the anonymous namespace to prevent polluting the outer
+// namespace.
+//
+// TestNameIs is copyable.
+class TestNameIs {
+ public:
+  // Constructor.
+  //
+  // TestNameIs has NO default constructor.
+  explicit TestNameIs(const char* name)
+      : name_(name) {}
+
+  // Returns true iff the test name of test_info matches name_.
+  bool operator()(const TestInfo * test_info) const {
+    return test_info && internal::String(test_info->name()).Compare(name_) == 0;
+  }
+
+ private:
+  internal::String name_;
+};
+
+}  // namespace
+
+// Finds and returns a TestInfo with the given name.  If one doesn't
+// exist, returns NULL.
+TestInfo * TestCase::GetTestInfo(const char* test_name) {
+  // Can we find a TestInfo with the given name?
+  internal::ListNode<TestInfo *> * const node = test_info_list_->FindIf(
+      TestNameIs(test_name));
+
+  // Returns the TestInfo found.
+  return node ? node->element() : NULL;
+}
+
+namespace internal {
+
+// Creates the test object, runs it, records its result, and then
+// deletes it.
+void TestInfoImpl::Run() {
+  if (!should_run_) return;
+
+  // Tells UnitTest where to store test result.
+  UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->set_current_test_info(parent_);
+
+  // Notifies the unit test event listener that a test is about to
+  // start.
+  UnitTestEventListenerInterface* const result_printer =
+    impl->result_printer();
+  result_printer->OnTestStart(parent_);
+
+  const TimeInMillis start = GetTimeInMillis();
+
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+#ifdef GTEST_OS_WINDOWS
+  // We are on Windows.
+  Test* test = NULL;
+
+  __try {
+    // Creates the test object.
+    test = (*maker_)();
+  } __except(internal::UnitTestOptions::GTestShouldProcessSEH(
+      GetExceptionCode())) {
+    AddExceptionThrownFailure(GetExceptionCode(),
+                              "the test fixture's constructor");
+    return;
+  }
+#else  // We are on Linux or Mac OS - exceptions are disabled.
+
+  // TODO(wan): If test->Run() throws, test won't be deleted.  This is
+  // not a problem now as we don't use exceptions.  If we were to
+  // enable exceptions, we should revise the following to be
+  // exception-safe.
+
+  // Creates the test object.
+  Test* test = (*maker_)();
+#endif  // GTEST_OS_WINDOWS
+
+  // Runs the test only if the constructor of the test fixture didn't
+  // generate a fatal failure.
+  if (!Test::HasFatalFailure()) {
+    test->Run();
+  }
+
+  // Deletes the test object.
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  delete test;
+  test = NULL;
+
+  result_.set_elapsed_time(GetTimeInMillis() - start);
+
+  // Notifies the unit test event listener that a test has just finished.
+  result_printer->OnTestEnd(parent_);
+
+  // Tells UnitTest to stop associating assertion results to this
+  // test.
+  impl->set_current_test_info(NULL);
+}
+
+}  // namespace internal
+
+// class TestCase
+
+// Gets the number of successful tests in this test case.
+int TestCase::successful_test_count() const {
+  return test_info_list_->CountIf(TestPassed);
+}
+
+// Gets the number of failed tests in this test case.
+int TestCase::failed_test_count() const {
+  return test_info_list_->CountIf(TestFailed);
+}
+
+int TestCase::disabled_test_count() const {
+  return test_info_list_->CountIf(TestDisabled);
+}
+
+// Get the number of tests in this test case that should run.
+int TestCase::test_to_run_count() const {
+  return test_info_list_->CountIf(ShouldRunTest);
+}
+
+// Gets the number of all tests.
+int TestCase::total_test_count() const {
+  return test_info_list_->size();
+}
+
+// Creates a TestCase with the given name.
+//
+// Arguments:
+//
+//   name:         name of the test case
+//   set_up_tc:    pointer to the function that sets up the test case
+//   tear_down_tc: pointer to the function that tears down the test case
+TestCase::TestCase(const char* name,
+                   Test::SetUpTestCaseFunc set_up_tc,
+                   Test::TearDownTestCaseFunc tear_down_tc)
+    : name_(name),
+      set_up_tc_(set_up_tc),
+      tear_down_tc_(tear_down_tc),
+      should_run_(false),
+      elapsed_time_(0) {
+  test_info_list_ = new internal::List<TestInfo *>;
+}
+
+// Destructor of TestCase.
+TestCase::~TestCase() {
+  // Deletes every Test in the collection.
+  test_info_list_->ForEach(internal::Delete<TestInfo>);
+
+  // Then deletes the Test collection.
+  delete test_info_list_;
+  test_info_list_ = NULL;
+}
+
+// Adds a test to this test case.  Will delete the test upon
+// destruction of the TestCase object.
+void TestCase::AddTestInfo(TestInfo * test_info) {
+  test_info_list_->PushBack(test_info);
+}
+
+// Runs every test in this TestCase.
+void TestCase::Run() {
+  if (!should_run_) return;
+
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->set_current_test_case(this);
+
+  UnitTestEventListenerInterface * const result_printer =
+      impl->result_printer();
+
+  result_printer->OnTestCaseStart(this);
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  set_up_tc_();
+
+  const internal::TimeInMillis start = internal::GetTimeInMillis();
+  test_info_list_->ForEach(internal::TestInfoImpl::RunTest);
+  elapsed_time_ = internal::GetTimeInMillis() - start;
+
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  tear_down_tc_();
+  result_printer->OnTestCaseEnd(this);
+  impl->set_current_test_case(NULL);
+}
+
+// Clears the results of all tests in this test case.
+void TestCase::ClearResult() {
+  test_info_list_->ForEach(internal::TestInfoImpl::ClearTestResult);
+}
+
+
+// class UnitTestEventListenerInterface
+
+// The virtual d'tor.
+UnitTestEventListenerInterface::~UnitTestEventListenerInterface() {
+}
+
+// A result printer that never prints anything.  Used in the child process
+// of an exec-style death test to avoid needless output clutter.
+class NullUnitTestResultPrinter : public UnitTestEventListenerInterface {};
+
+// Formats a countable noun.  Depending on its quantity, either the
+// singular form or the plural form is used. e.g.
+//
+// FormatCountableNoun(1, "formula", "formuli") returns "1 formula".
+// FormatCountableNoun(5, "book", "books") returns "5 books".
+static internal::String FormatCountableNoun(int count,
+                                            const char * singular_form,
+                                            const char * plural_form) {
+  return internal::String::Format("%d %s", count,
+                                  count == 1 ? singular_form : plural_form);
+}
+
+// Formats the count of tests.
+static internal::String FormatTestCount(int test_count) {
+  return FormatCountableNoun(test_count, "test", "tests");
+}
+
+// Formats the count of test cases.
+static internal::String FormatTestCaseCount(int test_case_count) {
+  return FormatCountableNoun(test_case_count, "test case", "test cases");
+}
+
+// Converts a TestPartResultType enum to human-friendly string
+// representation.  Both TPRT_NONFATAL_FAILURE and TPRT_FATAL_FAILURE
+// are translated to "Failure", as the user usually doesn't care about
+// the difference between the two when viewing the test result.
+static const char * TestPartResultTypeToString(TestPartResultType type) {
+  switch (type) {
+    case TPRT_SUCCESS:
+      return "Success";
+
+    case TPRT_NONFATAL_FAILURE:
+    case TPRT_FATAL_FAILURE:
+      return "Failure";
+  }
+
+  return "Unknown result type";
+}
+
+// Prints a TestPartResult.
+static void PrintTestPartResult(
+    const TestPartResult & test_part_result) {
+  const char * const file_name = test_part_result.file_name();
+
+  printf("%s", file_name == NULL ? "unknown file" : file_name);
+  if (test_part_result.line_number() >= 0) {
+    printf(":%d", test_part_result.line_number());
+  }
+  printf(": %s\n", TestPartResultTypeToString(test_part_result.type()));
+  printf("%s\n", test_part_result.message());
+  fflush(stdout);
+}
+
+// class PrettyUnitTestResultPrinter
+
+namespace internal {
+
+enum GTestColor {
+  COLOR_RED,
+  COLOR_GREEN,
+  COLOR_YELLOW
+};
+
+#ifdef _WIN32
+
+// Returns the character attribute for the given color.
+WORD GetColorAttribute(GTestColor color) {
+  switch (color) {
+    case COLOR_RED:    return FOREGROUND_RED;
+    case COLOR_GREEN:  return FOREGROUND_GREEN;
+    case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN;
+  }
+  return 0;
+}
+
+#else
+
+// Returns the ANSI color code for the given color.
+const char* GetAnsiColorCode(GTestColor color) {
+  switch (color) {
+    case COLOR_RED:     return "1";
+    case COLOR_GREEN:   return "2";
+    case COLOR_YELLOW:  return "3";
+  };
+  return NULL;
+}
+
+#endif  // _WIN32
+
+// Returns true iff Google Test should use colors in the output.
+bool ShouldUseColor(bool stdout_is_tty) {
+  const char* const gtest_color = GTEST_FLAG(color).c_str();
+
+  if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
+#ifdef _WIN32
+    // On Windows the TERM variable is usually not set, but the
+    // console there does support colors.
+    return stdout_is_tty;
+#else
+    // On non-Windows platforms, we rely on the TERM variable.
+    const char* const term = GetEnv("TERM");
+    const bool term_supports_color =
+        String::CStringEquals(term, "xterm") ||
+        String::CStringEquals(term, "xterm-color") ||
+        String::CStringEquals(term, "cygwin");
+    return stdout_is_tty && term_supports_color;
+#endif  // _WIN32
+  }
+
+  return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
+      String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
+      String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
+      String::CStringEquals(gtest_color, "1");
+  // We take "yes", "true", "t", and "1" as meaning "yes".  If the
+  // value is neither one of these nor "auto", we treat it as "no" to
+  // be conservative.
+}
+
+// Helpers for printing colored strings to stdout. Note that on Windows, we
+// cannot simply emit special characters and have the terminal change colors.
+// This routine must actually emit the characters rather than return a string
+// that would be colored when printed, as can be done on Linux.
+void ColoredPrintf(GTestColor color, const char* fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+
+  static const bool use_color = ShouldUseColor(isatty(fileno(stdout)) != 0);
+  // The '!= 0' comparison is necessary to satisfy MSVC 7.1.
+
+  if (!use_color) {
+    vprintf(fmt, args);
+    va_end(args);
+    return;
+  }
+
+#ifdef _WIN32
+  const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
+
+  // Gets the current text color.
+  CONSOLE_SCREEN_BUFFER_INFO buffer_info;
+  GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
+  const WORD old_color_attrs = buffer_info.wAttributes;
+
+  SetConsoleTextAttribute(stdout_handle,
+                          GetColorAttribute(color) | FOREGROUND_INTENSITY);
+  vprintf(fmt, args);
+
+  // Restores the text color.
+  SetConsoleTextAttribute(stdout_handle, old_color_attrs);
+#else
+  printf("\033[0;3%sm", GetAnsiColorCode(color));
+  vprintf(fmt, args);
+  printf("\033[m");  // Resets the terminal to default.
+#endif  // _WIN32
+  va_end(args);
+}
+
+}  // namespace internal
+
+using internal::ColoredPrintf;
+using internal::COLOR_RED;
+using internal::COLOR_GREEN;
+using internal::COLOR_YELLOW;
+
+// This class implements the UnitTestEventListenerInterface interface.
+//
+// Class PrettyUnitTestResultPrinter is copyable.
+class PrettyUnitTestResultPrinter : public UnitTestEventListenerInterface {
+ public:
+  PrettyUnitTestResultPrinter() {}
+  static void PrintTestName(const char * test_case, const char * test) {
+    printf("%s.%s", test_case, test);
+  }
+
+  // The following methods override what's in the
+  // UnitTestEventListenerInterface class.
+  virtual void OnUnitTestStart(const UnitTest * unit_test);
+  virtual void OnGlobalSetUpStart(const UnitTest*);
+  virtual void OnTestCaseStart(const TestCase * test_case);
+  virtual void OnTestStart(const TestInfo * test_info);
+  virtual void OnNewTestPartResult(const TestPartResult * result);
+  virtual void OnTestEnd(const TestInfo * test_info);
+  virtual void OnGlobalTearDownStart(const UnitTest*);
+  virtual void OnUnitTestEnd(const UnitTest * unit_test);
+
+ private:
+  internal::String test_case_name_;
+};
+
+// Called before the unit test starts.
+void PrettyUnitTestResultPrinter::OnUnitTestStart(
+    const UnitTest * unit_test) {
+  const char * const filter = GTEST_FLAG(filter).c_str();
+
+  // Prints the filter if it's not *.  This reminds the user that some
+  // tests may be skipped.
+  if (!internal::String::CStringEquals(filter, kUniversalFilter)) {
+    ColoredPrintf(COLOR_YELLOW,
+                  "Note: %s filter = %s\n", GTEST_NAME, filter);
+  }
+
+  const internal::UnitTestImpl* const impl = unit_test->impl();
+  ColoredPrintf(COLOR_GREEN,  "[==========] ");
+  printf("Running %s from %s.\n",
+         FormatTestCount(impl->test_to_run_count()).c_str(),
+         FormatTestCaseCount(impl->test_case_to_run_count()).c_str());
+  fflush(stdout);
+}
+
+void PrettyUnitTestResultPrinter::OnGlobalSetUpStart(const UnitTest*) {
+  ColoredPrintf(COLOR_GREEN,  "[----------] ");
+  printf("Global test environment set-up.\n");
+  fflush(stdout);
+}
+
+void PrettyUnitTestResultPrinter::OnTestCaseStart(
+    const TestCase * test_case) {
+  test_case_name_ = test_case->name();
+  const internal::String counts =
+      FormatCountableNoun(test_case->test_to_run_count(), "test", "tests");
+  ColoredPrintf(COLOR_GREEN, "[----------] ");
+  printf("%s from %s\n", counts.c_str(), test_case_name_.c_str());
+  fflush(stdout);
+}
+
+void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo * test_info) {
+  ColoredPrintf(COLOR_GREEN,  "[ RUN      ] ");
+  PrintTestName(test_case_name_.c_str(), test_info->name());
+  printf("\n");
+  fflush(stdout);
+}
+
+void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo * test_info) {
+  if (test_info->result()->Passed()) {
+    ColoredPrintf(COLOR_GREEN, "[       OK ] ");
+  } else {
+    ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
+  }
+  PrintTestName(test_case_name_.c_str(), test_info->name());
+  printf("\n");
+  fflush(stdout);
+}
+
+// Called after an assertion failure.
+void PrettyUnitTestResultPrinter::OnNewTestPartResult(
+    const TestPartResult * result) {
+  // If the test part succeeded, we don't need to do anything.
+  if (result->type() == TPRT_SUCCESS)
+    return;
+
+  // Print failure message from the assertion (e.g. expected this and got that).
+  PrintTestPartResult(*result);
+  fflush(stdout);
+}
+
+void PrettyUnitTestResultPrinter::OnGlobalTearDownStart(const UnitTest*) {
+  ColoredPrintf(COLOR_GREEN,  "[----------] ");
+  printf("Global test environment tear-down\n");
+  fflush(stdout);
+}
+
+namespace internal {
+
+// Internal helper for printing the list of failed tests.
+static void PrintFailedTestsPretty(const UnitTestImpl* impl) {
+  const int failed_test_count = impl->failed_test_count();
+  if (failed_test_count == 0) {
+    return;
+  }
+
+  for (const internal::ListNode<TestCase*>* node = impl->test_cases()->Head();
+       node != NULL; node = node->next()) {
+    const TestCase* const tc = node->element();
+    if (!tc->should_run() || (tc->failed_test_count() == 0)) {
+      continue;
+    }
+    for (const internal::ListNode<TestInfo*>* tinode =
+         tc->test_info_list().Head();
+         tinode != NULL; tinode = tinode->next()) {
+      const TestInfo* const ti = tinode->element();
+      if (!tc->ShouldRunTest(ti) || tc->TestPassed(ti)) {
+        continue;
+      }
+      ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
+      printf("%s.%s\n", ti->test_case_name(), ti->name());
+    }
+  }
+}
+
+}  // namespace internal
+
+void PrettyUnitTestResultPrinter::OnUnitTestEnd(
+    const UnitTest * unit_test) {
+  const internal::UnitTestImpl* const impl = unit_test->impl();
+
+  ColoredPrintf(COLOR_GREEN,  "[==========] ");
+  printf("%s from %s ran.\n",
+         FormatTestCount(impl->test_to_run_count()).c_str(),
+         FormatTestCaseCount(impl->test_case_to_run_count()).c_str());
+  ColoredPrintf(COLOR_GREEN,  "[  PASSED  ] ");
+  printf("%s.\n", FormatTestCount(impl->successful_test_count()).c_str());
+
+  int num_failures = impl->failed_test_count();
+  if (!impl->Passed()) {
+    const int failed_test_count = impl->failed_test_count();
+    ColoredPrintf(COLOR_RED,  "[  FAILED  ] ");
+    printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str());
+    internal::PrintFailedTestsPretty(impl);
+    printf("\n%2d FAILED %s\n", num_failures,
+                        num_failures == 1 ? "TEST" : "TESTS");
+  }
+
+  int num_disabled = impl->disabled_test_count();
+  if (num_disabled) {
+    if (!num_failures) {
+      printf("\n");  // Add a spacer if no FAILURE banner is displayed.
+    }
+    ColoredPrintf(COLOR_YELLOW,
+                  "  YOU HAVE %d DISABLED %s\n\n",
+                  num_disabled,
+                  num_disabled == 1 ? "TEST" : "TESTS");
+  }
+  // Ensure that Google Test output is printed before, e.g., heapchecker output.
+  fflush(stdout);
+}
+
+// End PrettyUnitTestResultPrinter
+
+// class UnitTestEventsRepeater
+//
+// This class forwards events to other event listeners.
+class UnitTestEventsRepeater : public UnitTestEventListenerInterface {
+ public:
+  typedef internal::List<UnitTestEventListenerInterface *> Listeners;
+  typedef internal::ListNode<UnitTestEventListenerInterface *> ListenersNode;
+  UnitTestEventsRepeater() {}
+  virtual ~UnitTestEventsRepeater();
+  void AddListener(UnitTestEventListenerInterface *listener);
+
+  virtual void OnUnitTestStart(const UnitTest* unit_test);
+  virtual void OnUnitTestEnd(const UnitTest* unit_test);
+  virtual void OnGlobalSetUpStart(const UnitTest* unit_test);
+  virtual void OnGlobalSetUpEnd(const UnitTest* unit_test);
+  virtual void OnGlobalTearDownStart(const UnitTest* unit_test);
+  virtual void OnGlobalTearDownEnd(const UnitTest* unit_test);
+  virtual void OnTestCaseStart(const TestCase* test_case);
+  virtual void OnTestCaseEnd(const TestCase* test_case);
+  virtual void OnTestStart(const TestInfo* test_info);
+  virtual void OnTestEnd(const TestInfo* test_info);
+  virtual void OnNewTestPartResult(const TestPartResult* result);
+
+ private:
+  Listeners listeners_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN(UnitTestEventsRepeater);
+};
+
+UnitTestEventsRepeater::~UnitTestEventsRepeater() {
+  for (ListenersNode* listener = listeners_.Head();
+       listener != NULL;
+       listener = listener->next()) {
+    delete listener->element();
+  }
+}
+
+void UnitTestEventsRepeater::AddListener(
+    UnitTestEventListenerInterface *listener) {
+  listeners_.PushBack(listener);
+}
+
+// Since the methods are identical, use a macro to reduce boilerplate.
+// This defines a member that repeats the call to all listeners.
+#define GTEST_REPEATER_METHOD(Name, Type) \
+void UnitTestEventsRepeater::Name(const Type* parameter) { \
+  for (ListenersNode* listener = listeners_.Head(); \
+       listener != NULL; \
+       listener = listener->next()) { \
+    listener->element()->Name(parameter); \
+  } \
+}
+
+GTEST_REPEATER_METHOD(OnUnitTestStart, UnitTest)
+GTEST_REPEATER_METHOD(OnUnitTestEnd, UnitTest)
+GTEST_REPEATER_METHOD(OnGlobalSetUpStart, UnitTest)
+GTEST_REPEATER_METHOD(OnGlobalSetUpEnd, UnitTest)
+GTEST_REPEATER_METHOD(OnGlobalTearDownStart, UnitTest)
+GTEST_REPEATER_METHOD(OnGlobalTearDownEnd, UnitTest)
+GTEST_REPEATER_METHOD(OnTestCaseStart, TestCase)
+GTEST_REPEATER_METHOD(OnTestCaseEnd, TestCase)
+GTEST_REPEATER_METHOD(OnTestStart, TestInfo)
+GTEST_REPEATER_METHOD(OnTestEnd, TestInfo)
+GTEST_REPEATER_METHOD(OnNewTestPartResult, TestPartResult)
+
+#undef GTEST_REPEATER_METHOD
+
+// End PrettyUnitTestResultPrinter
+
+// This class generates an XML output file.
+class XmlUnitTestResultPrinter : public UnitTestEventListenerInterface {
+ public:
+  explicit XmlUnitTestResultPrinter(const char* output_file);
+
+  virtual void OnUnitTestEnd(const UnitTest* unit_test);
+
+ private:
+  // Is c a whitespace character that is normalized to a space character
+  // when it appears in an XML attribute value?
+  static bool IsNormalizableWhitespace(char c) {
+    return c == 0x9 || c == 0xA || c == 0xD;
+  }
+
+  // May c appear in a well-formed XML document?
+  static bool IsValidXmlCharacter(char c) {
+    return IsNormalizableWhitespace(c) || c >= 0x20;
+  }
+
+  // Returns an XML-escaped copy of the input string str.  If
+  // is_attribute is true, the text is meant to appear as an attribute
+  // value, and normalizable whitespace is preserved by replacing it
+  // with character references.
+  static internal::String EscapeXml(const char* str,
+                                    bool is_attribute);
+
+  // Convenience wrapper around EscapeXml when str is an attribute value.
+  static internal::String EscapeXmlAttribute(const char* str) {
+    return EscapeXml(str, true);
+  }
+
+  // Convenience wrapper around EscapeXml when str is not an attribute value.
+  static internal::String EscapeXmlText(const char* str) {
+    return EscapeXml(str, false);
+  }
+
+  // Prints an XML representation of a TestInfo object.
+  static void PrintXmlTestInfo(FILE* out,
+                               const char* test_case_name,
+                               const TestInfo* test_info);
+
+  // Prints an XML representation of a TestCase object
+  static void PrintXmlTestCase(FILE* out, const TestCase* test_case);
+
+  // Prints an XML summary of unit_test to output stream out.
+  static void PrintXmlUnitTest(FILE* out, const UnitTest* unit_test);
+
+  // Produces a string representing the test properties in a result as space
+  // delimited XML attributes based on the property key="value" pairs.
+  // When the String is not empty, it includes a space at the beginning,
+  // to delimit this attribute from prior attributes.
+  static internal::String TestPropertiesAsXmlAttributes(
+      const internal::TestResult* result);
+
+  // The output file.
+  const internal::String output_file_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN(XmlUnitTestResultPrinter);
+};
+
+// Creates a new XmlUnitTestResultPrinter.
+XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
+    : output_file_(output_file) {
+  if (output_file_.c_str() == NULL || output_file_.empty()) {
+    fprintf(stderr, "XML output file may not be null\n");
+    fflush(stderr);
+    exit(EXIT_FAILURE);
+  }
+}
+
+// Called after the unit test ends.
+void XmlUnitTestResultPrinter::OnUnitTestEnd(const UnitTest* unit_test) {
+  FILE* xmlout = NULL;
+  internal::FilePath output_file(output_file_);
+  internal::FilePath output_dir(output_file.RemoveFileName());
+
+  if (output_dir.CreateDirectoriesRecursively()) {
+  // MSVC 8 deprecates fopen(), so we want to suppress warning 4996
+  // (deprecated function) there.
+#ifdef GTEST_OS_WINDOWS
+  // We are on Windows.
+#pragma warning(push)          // Saves the current warning state.
+#pragma warning(disable:4996)  // Temporarily disables warning 4996.
+    xmlout = fopen(output_file_.c_str(), "w");
+#pragma warning(pop)           // Restores the warning state.
+#else  // We are on Linux or Mac OS.
+    xmlout = fopen(output_file_.c_str(), "w");
+#endif  // GTEST_OS_WINDOWS
+  }
+  if (xmlout == NULL) {
+    // TODO(wan): report the reason of the failure.
+    //
+    // We don't do it for now as:
+    //
+    //   1. There is no urgent need for it.
+    //   2. It's a bit involved to make the errno variable thread-safe on
+    //      all three operating systems (Linux, Windows, and Mac OS).
+    //   3. To interpret the meaning of errno in a thread-safe way,
+    //      we need the strerror_r() function, which is not available on
+    //      Windows.
+    fprintf(stderr,
+            "Unable to open file \"%s\"\n",
+            output_file_.c_str());
+    fflush(stderr);
+    exit(EXIT_FAILURE);
+  }
+  PrintXmlUnitTest(xmlout, unit_test);
+  fclose(xmlout);
+}
+
+// Returns an XML-escaped copy of the input string str.  If is_attribute
+// is true, the text is meant to appear as an attribute value, and
+// normalizable whitespace is preserved by replacing it with character
+// references.
+//
+// Invalid XML characters in str, if any, are stripped from the output.
+// It is expected that most, if not all, of the text processed by this
+// module will consist of ordinary English text.
+// If this module is ever modified to produce version 1.1 XML output,
+// most invalid characters can be retained using character references.
+// TODO(wan): It might be nice to have a minimally invasive, human-readable
+// escaping scheme for invalid characters, rather than dropping them.
+internal::String XmlUnitTestResultPrinter::EscapeXml(const char* str,
+                                                     bool is_attribute) {
+  Message m;
+
+  if (str != NULL) {
+    for (const char* src = str; *src; ++src) {
+      switch (*src) {
+        case '<':
+          m << "&lt;";
+          break;
+        case '>':
+          m << "&gt;";
+          break;
+        case '&':
+          m << "&amp;";
+          break;
+        case '\'':
+          if (is_attribute)
+            m << "&apos;";
+          else
+            m << '\'';
+          break;
+        case '"':
+          if (is_attribute)
+            m << "&quot;";
+          else
+            m << '"';
+          break;
+        default:
+          if (IsValidXmlCharacter(*src)) {
+            if (is_attribute && IsNormalizableWhitespace(*src))
+              m << internal::String::Format("&#x%02X;", unsigned(*src));
+            else
+              m << *src;
+          }
+          break;
+      }
+    }
+  }
+
+  return m.GetString();
+}
+
+
+// The following routines generate an XML representation of a UnitTest
+// object.
+//
+// This is how Google Test concepts map to the DTD:
+//
+// <testsuite name="AllTests">         <-- corresponds to a UnitTest object
+//   <testsuite name="testcase-name">  <-- corresponds to a TestCase object
+//     <testcase name="test-name">     <-- corresponds to a TestInfo object
+//       <failure message="..." />
+//       <failure message="..." />     <-- individual assertion failures
+//       <failure message="..." />
+//     </testcase>
+//   </testsuite>
+// </testsuite>
+
+// Prints an XML representation of a TestInfo object.
+// TODO(wan): There is also value in printing properties with the plain printer.
+void XmlUnitTestResultPrinter::PrintXmlTestInfo(FILE* out,
+                                                const char* test_case_name,
+                                                const TestInfo* test_info) {
+  const internal::TestResult * const result = test_info->result();
+  const internal::List<TestPartResult> &results = result->test_part_results();
+  fprintf(out,
+          "    <testcase name=\"%s\" status=\"%s\" time=\"%s\" "
+          "classname=\"%s\"%s",
+          EscapeXmlAttribute(test_info->name()).c_str(),
+          test_info->should_run() ? "run" : "notrun",
+          internal::StreamableToString(result->elapsed_time()).c_str(),
+          EscapeXmlAttribute(test_case_name).c_str(),
+          TestPropertiesAsXmlAttributes(result).c_str());
+
+  int failures = 0;
+  for (const internal::ListNode<TestPartResult>* part_node = results.Head();
+       part_node != NULL;
+       part_node = part_node->next()) {
+    const TestPartResult& part = part_node->element();
+    if (part.failed()) {
+      const internal::String message =
+          internal::String::Format("%s:%d\n%s", part.file_name(),
+                                   part.line_number(), part.message());
+      if (++failures == 1)
+        fprintf(out, ">\n");
+      fprintf(out,
+              "      <failure message=\"%s\" type=\"\"/>\n",
+              EscapeXmlAttribute(message.c_str()).c_str());
+    }
+  }
+
+  if (failures == 0)
+    fprintf(out, " />\n");
+  else
+    fprintf(out, "    </testcase>\n");
+}
+
+// Prints an XML representation of a TestCase object
+void XmlUnitTestResultPrinter::PrintXmlTestCase(FILE* out,
+                                                const TestCase* test_case) {
+  fprintf(out,
+          "  <testsuite name=\"%s\" tests=\"%d\" failures=\"%d\" "
+          "disabled=\"%d\" ",
+          EscapeXmlAttribute(test_case->name()).c_str(),
+          test_case->total_test_count(),
+          test_case->failed_test_count(),
+          test_case->disabled_test_count());
+  fprintf(out,
+          "errors=\"0\" time=\"%s\">\n",
+          internal::StreamableToString(test_case->elapsed_time()).c_str());
+  for (const internal::ListNode<TestInfo*>* info_node =
+         test_case->test_info_list().Head();
+       info_node != NULL;
+       info_node = info_node->next()) {
+    PrintXmlTestInfo(out, test_case->name(), info_node->element());
+  }
+  fprintf(out, "  </testsuite>\n");
+}
+
+// Prints an XML summary of unit_test to output stream out.
+void XmlUnitTestResultPrinter::PrintXmlUnitTest(FILE* out,
+                                                const UnitTest* unit_test) {
+  const internal::UnitTestImpl* const impl = unit_test->impl();
+  fprintf(out, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+  fprintf(out,
+          "<testsuite tests=\"%d\" failures=\"%d\" disabled=\"%d\" "
+          "errors=\"0\" time=\"%s\" ",
+          impl->total_test_count(),
+          impl->failed_test_count(),
+          impl->disabled_test_count(),
+          internal::StreamableToString(impl->elapsed_time()).c_str());
+  fprintf(out, "name=\"AllTests\">\n");
+  for (const internal::ListNode<TestCase*>* case_node =
+       impl->test_cases()->Head();
+       case_node != NULL;
+       case_node = case_node->next()) {
+    PrintXmlTestCase(out, case_node->element());
+  }
+  fprintf(out, "</testsuite>\n");
+}
+
+// Produces a string representing the test properties in a result as space
+// delimited XML attributes based on the property key="value" pairs.
+internal::String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
+    const internal::TestResult* result) {
+  using internal::TestProperty;
+  Message attributes;
+  const internal::List<TestProperty>& properties = result->test_properties();
+  for (const internal::ListNode<TestProperty>* property_node =
+       properties.Head();
+       property_node != NULL;
+       property_node = property_node->next()) {
+    const TestProperty& property = property_node->element();
+    attributes << " " << property.key() << "="
+        << "\"" << EscapeXmlAttribute(property.value()) << "\"";
+  }
+  return attributes.GetString();
+}
+
+// End XmlUnitTestResultPrinter
+
+namespace internal {
+
+// Class ScopedTrace
+
+// Pushes the given source file location and message onto a per-thread
+// trace stack maintained by Google Test.
+// L < UnitTest::mutex_
+ScopedTrace::ScopedTrace(const char* file, int line, const Message& message) {
+  TraceInfo trace;
+  trace.file = file;
+  trace.line = line;
+  trace.message = message.GetString();
+
+  UnitTest::GetInstance()->PushGTestTrace(trace);
+}
+
+// Pops the info pushed by the c'tor.
+// L < UnitTest::mutex_
+ScopedTrace::~ScopedTrace() {
+  UnitTest::GetInstance()->PopGTestTrace();
+}
+
+
+// class OsStackTraceGetter
+
+// Returns the current OS stack trace as a String.  Parameters:
+//
+//   max_depth  - the maximum number of stack frames to be included
+//                in the trace.
+//   skip_count - the number of top frames to be skipped; doesn't count
+//                against max_depth.
+//
+// L < mutex_
+// We use "L < mutex_" to denote that the function may acquire mutex_.
+String OsStackTraceGetter::CurrentStackTrace(int, int) {
+  return String("");
+}
+
+// L < mutex_
+void OsStackTraceGetter::UponLeavingGTest() {
+}
+
+const char* const
+OsStackTraceGetter::kElidedFramesMarker =
+    "... " GTEST_NAME " internal frames ...";
+
+}  // namespace internal
+
+// class UnitTest
+
+// Gets the singleton UnitTest object.  The first time this method is
+// called, a UnitTest object is constructed and returned.  Consecutive
+// calls will return the same object.
+//
+// We don't protect this under mutex_ as a user is not supposed to
+// call this before main() starts, from which point on the return
+// value will never change.
+UnitTest * UnitTest::GetInstance() {
+  // When compiled with MSVC 7.1 in optimized mode, destroying the
+  // UnitTest object upon exiting the program messes up the exit code,
+  // causing successful tests to appear failed.  We have to use a
+  // different implementation in this case to bypass the compiler bug.
+  // This implementation makes the compiler happy, at the cost of
+  // leaking the UnitTest object.
+#if _MSC_VER == 1310 && !defined(_DEBUG)  // MSVC 7.1 and optimized build.
+  static UnitTest* const instance = new UnitTest;
+  return instance;
+#else
+  static UnitTest instance;
+  return &instance;
+#endif  // _MSC_VER==1310 && !defined(_DEBUG)
+}
+
+// Registers and returns a global test environment.  When a test
+// program is run, all global test environments will be set-up in the
+// order they were registered.  After all tests in the program have
+// finished, all global test environments will be torn-down in the
+// *reverse* order they were registered.
+//
+// The UnitTest object takes ownership of the given environment.
+//
+// We don't protect this under mutex_, as we only support calling it
+// from the main thread.
+Environment* UnitTest::AddEnvironment(Environment* env) {
+  if (env == NULL) {
+    return NULL;
+  }
+
+  impl_->environments()->PushBack(env);
+  impl_->environments_in_reverse_order()->PushFront(env);
+  return env;
+}
+
+// Adds a TestPartResult to the current TestResult object.  All Google Test
+// assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call
+// this to report their results.  The user code should use the
+// assertion macros instead of calling this directly.
+// L < mutex_
+void UnitTest::AddTestPartResult(TestPartResultType result_type,
+                                 const char* file_name,
+                                 int line_number,
+                                 const internal::String& message,
+                                 const internal::String& os_stack_trace) {
+  Message msg;
+  msg << message;
+
+  internal::MutexLock lock(&mutex_);
+  if (impl_->gtest_trace_stack()->size() > 0) {
+    msg << "\n" << GTEST_NAME << " trace:";
+
+    for (internal::ListNode<internal::TraceInfo>* node =
+         impl_->gtest_trace_stack()->Head();
+         node != NULL;
+         node = node->next()) {
+      const internal::TraceInfo& trace = node->element();
+      msg << "\n" << trace.file << ":" << trace.line << ": " << trace.message;
+    }
+  }
+
+  if (os_stack_trace.c_str() != NULL && !os_stack_trace.empty()) {
+    msg << "\nStack trace:\n" << os_stack_trace;
+  }
+
+  const TestPartResult result =
+    TestPartResult(result_type, file_name, line_number,
+                   msg.GetString().c_str());
+  impl_->test_part_result_reporter()->ReportTestPartResult(result);
+
+  // If this is a failure and the user wants the debugger to break on
+  // failures ...
+  if (result_type != TPRT_SUCCESS && GTEST_FLAG(break_on_failure)) {
+    // ... then we generate a seg fault.
+    *static_cast<int*>(NULL) = 1;
+  }
+}
+
+// Creates and adds a property to the current TestResult. If a property matching
+// the supplied value already exists, updates its value instead.
+void UnitTest::RecordPropertyForCurrentTest(const char* key,
+                                            const char* value) {
+  const internal::TestProperty test_property(key, value);
+  impl_->current_test_result()->RecordProperty(test_property);
+}
+
+// Runs all tests in this UnitTest object and prints the result.
+// Returns 0 if successful, or 1 otherwise.
+//
+// We don't protect this under mutex_, as we only support calling it
+// from the main thread.
+int UnitTest::Run() {
+#ifdef GTEST_OS_WINDOWS
+
+#if !defined(_WIN32_WCE)
+  // SetErrorMode doesn't exist on CE.
+  if (GTEST_FLAG(catch_exceptions)) {
+    // The user wants Google Test to catch exceptions thrown by the tests.
+
+    // This lets fatal errors be handled by us, instead of causing pop-ups.
+    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
+                 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
+  }
+#endif  // _WIN32_WCE
+
+  __try {
+    return impl_->RunAllTests();
+  } __except(internal::UnitTestOptions::GTestShouldProcessSEH(
+      GetExceptionCode())) {
+    printf("Exception thrown with code 0x%x.\nFAIL\n", GetExceptionCode());
+    fflush(stdout);
+    return 1;
+  }
+
+#else
+  // We are on Linux or Mac OS.  There is no exception of any kind.
+
+  return impl_->RunAllTests();
+#endif  // GTEST_OS_WINDOWS
+}
+
+// Returns the TestCase object for the test that's currently running,
+// or NULL if no test is running.
+// L < mutex_
+const TestCase* UnitTest::current_test_case() const {
+  internal::MutexLock lock(&mutex_);
+  return impl_->current_test_case();
+}
+
+// Returns the TestInfo object for the test that's currently running,
+// or NULL if no test is running.
+// L < mutex_
+const TestInfo* UnitTest::current_test_info() const {
+  internal::MutexLock lock(&mutex_);
+  return impl_->current_test_info();
+}
+
+// Creates an empty UnitTest.
+UnitTest::UnitTest() {
+  impl_ = new internal::UnitTestImpl(this);
+}
+
+// Destructor of UnitTest.
+UnitTest::~UnitTest() {
+  delete impl_;
+}
+
+// Pushes a trace defined by SCOPED_TRACE() on to the per-thread
+// Google Test trace stack.
+// L < mutex_
+void UnitTest::PushGTestTrace(const internal::TraceInfo& trace) {
+  internal::MutexLock lock(&mutex_);
+  impl_->gtest_trace_stack()->PushFront(trace);
+}
+
+// Pops a trace from the per-thread Google Test trace stack.
+// L < mutex_
+void UnitTest::PopGTestTrace() {
+  internal::MutexLock lock(&mutex_);
+  impl_->gtest_trace_stack()->PopFront(NULL);
+}
+
+namespace internal {
+
+UnitTestImpl::UnitTestImpl(UnitTest* parent)
+    : parent_(parent),
+      test_cases_(),
+      last_death_test_case_(NULL),
+      current_test_case_(NULL),
+      current_test_info_(NULL),
+      ad_hoc_test_result_(),
+      result_printer_(NULL),
+      os_stack_trace_getter_(NULL),
+#ifdef GTEST_HAS_DEATH_TEST
+      elapsed_time_(0),
+      internal_run_death_test_flag_(NULL),
+      death_test_factory_(new DefaultDeathTestFactory) {
+#else
+      elapsed_time_(0) {
+#endif  // GTEST_HAS_DEATH_TEST
+  // We do the assignment here instead of in the initializer list, as
+  // doing that latter causes MSVC to issue a warning about using
+  // 'this' in initializers.
+  test_part_result_reporter_ = this;
+}
+
+UnitTestImpl::~UnitTestImpl() {
+  // Deletes every TestCase.
+  test_cases_.ForEach(internal::Delete<TestCase>);
+
+  // Deletes every Environment.
+  environments_.ForEach(internal::Delete<Environment>);
+
+  // Deletes the current test result printer.
+  delete result_printer_;
+
+  delete os_stack_trace_getter_;
+}
+
+// A predicate that checks the name of a TestCase against a known
+// value.
+//
+// This is used for implementation of the UnitTest class only.  We put
+// it in the anonymous namespace to prevent polluting the outer
+// namespace.
+//
+// TestCaseNameIs is copyable.
+class TestCaseNameIs {
+ public:
+  // Constructor.
+  explicit TestCaseNameIs(const String& name)
+      : name_(name) {}
+
+  // Returns true iff the name of test_case matches name_.
+  bool operator()(const TestCase* test_case) const {
+    return test_case != NULL && strcmp(test_case->name(), name_.c_str()) == 0;
+  }
+
+ private:
+  String name_;
+};
+
+// Finds and returns a TestCase with the given name.  If one doesn't
+// exist, creates one and returns it.
+//
+// Arguments:
+//
+//   test_case_name: name of the test case
+//   set_up_tc:      pointer to the function that sets up the test case
+//   tear_down_tc:   pointer to the function that tears down the test case
+TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
+                                    Test::SetUpTestCaseFunc set_up_tc,
+                                    Test::TearDownTestCaseFunc tear_down_tc) {
+  // Can we find a TestCase with the given name?
+  internal::ListNode<TestCase*>* node = test_cases_.FindIf(
+      TestCaseNameIs(test_case_name));
+
+  if (node == NULL) {
+    // No.  Let's create one.
+    TestCase* const test_case =
+      new TestCase(test_case_name, set_up_tc, tear_down_tc);
+
+    // Is this a death test case?
+    if (String(test_case_name).EndsWith("DeathTest")) {
+      // Yes.  Inserts the test case after the last death test case
+      // defined so far.
+      node = test_cases_.InsertAfter(last_death_test_case_, test_case);
+      last_death_test_case_ = node;
+    } else {
+      // No.  Appends to the end of the list.
+      test_cases_.PushBack(test_case);
+      node = test_cases_.Last();
+    }
+  }
+
+  // Returns the TestCase found.
+  return node->element();
+}
+
+// Helpers for setting up / tearing down the given environment.  They
+// are for use in the List::ForEach() method.
+static void SetUpEnvironment(Environment* env) { env->SetUp(); }
+static void TearDownEnvironment(Environment* env) { env->TearDown(); }
+
+// Runs all tests in this UnitTest object, prints the result, and
+// returns 0 if all tests are successful, or 1 otherwise.  If any
+// exception is thrown during a test on Windows, this test is
+// considered to be failed, but the rest of the tests will still be
+// run.  (We disable exceptions on Linux and Mac OS X, so the issue
+// doesn't apply there.)
+int UnitTestImpl::RunAllTests() {
+  // Makes sure InitGoogleTest() was called.
+  if (!GTestIsInitialized()) {
+    printf("%s",
+           "\nThis test program did NOT call ::testing::InitGoogleTest "
+           "before calling RUN_ALL_TESTS().  Please fix it.\n");
+    return 1;
+  }
+
+  // Lists all the tests and exits if the --gtest_list_tests
+  // flag was specified.
+  if (GTEST_FLAG(list_tests)) {
+    ListAllTests();
+    return 0;
+  }
+
+  // True iff we are in a subprocess for running a thread-safe-style
+  // death test.
+  bool in_subprocess_for_death_test = false;
+
+#ifdef GTEST_HAS_DEATH_TEST
+  internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag());
+  in_subprocess_for_death_test = (internal_run_death_test_flag_.get() != NULL);
+#endif  // GTEST_HAS_DEATH_TEST
+
+  UnitTestEventListenerInterface * const printer = result_printer();
+
+  // Compares the full test names with the filter to decide which
+  // tests to run.
+  const bool has_tests_to_run = FilterTests() > 0;
+  // True iff at least one test has failed.
+  bool failed = false;
+
+  // How many times to repeat the tests?  We don't want to repeat them
+  // when we are inside the subprocess of a death test.
+  const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat);
+  // Repeats forever if the repeat count is negative.
+  const bool forever = repeat < 0;
+  for (int i = 0; forever || i != repeat; i++) {
+    if (repeat != 1) {
+      printf("\nRepeating all tests (iteration %d) . . .\n\n", i + 1);
+    }
+
+    // Tells the unit test event listener that the tests are about to
+    // start.
+    printer->OnUnitTestStart(parent_);
+
+    const TimeInMillis start = GetTimeInMillis();
+
+    // Runs each test case if there is at least one test to run.
+    if (has_tests_to_run) {
+      // Sets up all environments beforehand.
+      printer->OnGlobalSetUpStart(parent_);
+      environments_.ForEach(SetUpEnvironment);
+      printer->OnGlobalSetUpEnd(parent_);
+
+      // Runs the tests only if there was no fatal failure during global
+      // set-up.
+      if (!Test::HasFatalFailure()) {
+        test_cases_.ForEach(TestCase::RunTestCase);
+      }
+
+      // Tears down all environments in reverse order afterwards.
+      printer->OnGlobalTearDownStart(parent_);
+      environments_in_reverse_order_.ForEach(TearDownEnvironment);
+      printer->OnGlobalTearDownEnd(parent_);
+    }
+
+    elapsed_time_ = GetTimeInMillis() - start;
+
+    // Tells the unit test event listener that the tests have just
+    // finished.
+    printer->OnUnitTestEnd(parent_);
+
+    // Gets the result and clears it.
+    if (!Passed()) {
+      failed = true;
+    }
+    ClearResult();
+  }
+
+  // Returns 0 if all tests passed, or 1 other wise.
+  return failed ? 1 : 0;
+}
+
+// Compares the name of each test with the user-specified filter to
+// decide whether the test should be run, then records the result in
+// each TestCase and TestInfo object.
+// Returns the number of tests that should run.
+int UnitTestImpl::FilterTests() {
+  int num_runnable_tests = 0;
+  for (const internal::ListNode<TestCase *> *test_case_node =
+       test_cases_.Head();
+       test_case_node != NULL;
+       test_case_node = test_case_node->next()) {
+    TestCase * const test_case = test_case_node->element();
+    const String &test_case_name = test_case->name();
+    test_case->set_should_run(false);
+
+    for (const internal::ListNode<TestInfo *> *test_info_node =
+           test_case->test_info_list().Head();
+         test_info_node != NULL;
+         test_info_node = test_info_node->next()) {
+      TestInfo * const test_info = test_info_node->element();
+      const String test_name(test_info->name());
+      // A test is disabled if test case name or test name matches
+      // kDisableTestPattern.
+      const bool is_disabled =
+        internal::UnitTestOptions::PatternMatchesString(kDisableTestPattern,
+            test_case_name.c_str()) ||
+        internal::UnitTestOptions::PatternMatchesString(kDisableTestPattern,
+            test_name.c_str());
+      test_info->impl()->set_is_disabled(is_disabled);
+
+      const bool should_run = !is_disabled &&
+          internal::UnitTestOptions::FilterMatchesTest(test_case_name,
+                                                       test_name);
+      test_info->impl()->set_should_run(should_run);
+      test_case->set_should_run(test_case->should_run() || should_run);
+      if (should_run) {
+        num_runnable_tests++;
+      }
+    }
+  }
+  return num_runnable_tests;
+}
+
+// Lists all tests by name.
+void UnitTestImpl::ListAllTests() {
+  for (const internal::ListNode<TestCase*>* test_case_node = test_cases_.Head();
+       test_case_node != NULL;
+       test_case_node = test_case_node->next()) {
+    const TestCase* const test_case = test_case_node->element();
+
+    // Prints the test case name following by an indented list of test nodes.
+    printf("%s.\n", test_case->name());
+
+    for (const internal::ListNode<TestInfo*>* test_info_node =
+         test_case->test_info_list().Head();
+         test_info_node != NULL;
+         test_info_node = test_info_node->next()) {
+      const TestInfo* const test_info = test_info_node->element();
+
+      printf("  %s\n", test_info->name());
+    }
+  }
+  fflush(stdout);
+}
+
+// Sets the unit test result printer.
+//
+// Does nothing if the input and the current printer object are the
+// same; otherwise, deletes the old printer object and makes the
+// input the current printer.
+void UnitTestImpl::set_result_printer(
+    UnitTestEventListenerInterface* result_printer) {
+  if (result_printer_ != result_printer) {
+    delete result_printer_;
+    result_printer_ = result_printer;
+  }
+}
+
+// Returns the current unit test result printer if it is not NULL;
+// otherwise, creates an appropriate result printer, makes it the
+// current printer, and returns it.
+UnitTestEventListenerInterface* UnitTestImpl::result_printer() {
+  if (result_printer_ != NULL) {
+    return result_printer_;
+  }
+
+#ifdef GTEST_HAS_DEATH_TEST
+  if (internal_run_death_test_flag_.get() != NULL) {
+    result_printer_ = new NullUnitTestResultPrinter;
+    return result_printer_;
+  }
+#endif  // GTEST_HAS_DEATH_TEST
+
+  UnitTestEventsRepeater *repeater = new UnitTestEventsRepeater;
+  const String& output_format = internal::UnitTestOptions::GetOutputFormat();
+  if (output_format == "xml") {
+    repeater->AddListener(new XmlUnitTestResultPrinter(
+        internal::UnitTestOptions::GetOutputFile().c_str()));
+  } else if (output_format != "") {
+      printf("WARNING: unrecognized output format \"%s\" ignored.\n",
+             output_format.c_str());
+      fflush(stdout);
+  }
+  repeater->AddListener(new PrettyUnitTestResultPrinter);
+  result_printer_ = repeater;
+  return result_printer_;
+}
+
+// Sets the OS stack trace getter.
+//
+// Does nothing if the input and the current OS stack trace getter are
+// the same; otherwise, deletes the old getter and makes the input the
+// current getter.
+void UnitTestImpl::set_os_stack_trace_getter(
+    OsStackTraceGetterInterface* getter) {
+  if (os_stack_trace_getter_ != getter) {
+    delete os_stack_trace_getter_;
+    os_stack_trace_getter_ = getter;
+  }
+}
+
+// Returns the current OS stack trace getter if it is not NULL;
+// otherwise, creates an OsStackTraceGetter, makes it the current
+// getter, and returns it.
+OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
+  if (os_stack_trace_getter_ == NULL) {
+    os_stack_trace_getter_ = new OsStackTraceGetter;
+  }
+
+  return os_stack_trace_getter_;
+}
+
+// Returns the TestResult for the test that's currently running, or
+// the TestResult for the ad hoc test if no test is running.
+internal::TestResult* UnitTestImpl::current_test_result() {
+  return current_test_info_ ?
+    current_test_info_->impl()->result() : &ad_hoc_test_result_;
+}
+
+// TestInfoImpl constructor.
+TestInfoImpl::TestInfoImpl(TestInfo* parent,
+                           const char* test_case_name,
+                           const char* name,
+                           TypeId fixture_class_id,
+                           TestMaker maker) :
+    parent_(parent),
+    test_case_name_(String(test_case_name)),
+    name_(String(name)),
+    fixture_class_id_(fixture_class_id),
+    should_run_(false),
+    is_disabled_(false),
+    maker_(maker) {
+}
+
+// TestInfoImpl destructor.
+TestInfoImpl::~TestInfoImpl() {
+}
+
+}  // namespace internal
+
+namespace internal {
+
+// Parses a string as a command line flag.  The string should have
+// the format "--flag=value".  When def_optional is true, the "=value"
+// part can be omitted.
+//
+// Returns the value of the flag, or NULL if the parsing failed.
+const char* ParseFlagValue(const char* str,
+                           const char* flag,
+                           bool def_optional) {
+  // str and flag must not be NULL.
+  if (str == NULL || flag == NULL) return NULL;
+
+  // The flag must start with "--" followed by GTEST_FLAG_PREFIX.
+  const String flag_str = String::Format("--%s%s", GTEST_FLAG_PREFIX, flag);
+  const size_t flag_len = flag_str.GetLength();
+  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;
+
+  // Skips the flag name.
+  const char* flag_end = str + flag_len;
+
+  // When def_optional is true, it's OK to not have a "=value" part.
+  if (def_optional && (flag_end[0] == '\0')) {
+    return flag_end;
+  }
+
+  // If def_optional is true and there are more characters after the
+  // flag name, or if def_optional is false, there must be a '=' after
+  // the flag name.
+  if (flag_end[0] != '=') return NULL;
+
+  // Returns the string after "=".
+  return flag_end + 1;
+}
+
+// Parses a string for a bool flag, in the form of either
+// "--flag=value" or "--flag".
+//
+// In the former case, the value is taken as true as long as it does
+// not start with '0', 'f', or 'F'.
+//
+// In the latter case, the value is taken as true.
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseFlagValue(str, flag, true);
+
+  // Aborts if the parsing failed.
+  if (value_str == NULL) return false;
+
+  // Converts the string value to a bool.
+  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
+  return true;
+}
+
+// Parses a string for an Int32 flag, in the form of
+// "--flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+bool ParseInt32Flag(const char* str, const char* flag, Int32* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseFlagValue(str, flag, false);
+
+  // Aborts if the parsing failed.
+  if (value_str == NULL) return false;
+
+  // Sets *value to the value of the flag.
+  return ParseInt32(Message() << "The value of flag --" << flag,
+                    value_str, value);
+}
+
+// Parses a string for a string flag, in the form of
+// "--flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+bool ParseStringFlag(const char* str, const char* flag, String* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseFlagValue(str, flag, false);
+
+  // Aborts if the parsing failed.
+  if (value_str == NULL) return false;
+
+  // Sets *value to the value of the flag.
+  *value = value_str;
+  return true;
+}
+
+// The internal implementation of InitGoogleTest().
+//
+// The type parameter CharType can be instantiated to either char or
+// wchar_t.
+template <typename CharType>
+void InitGoogleTestImpl(int* argc, CharType** argv) {
+  g_parse_gtest_flags_called = true;
+  if (*argc <= 0) return;
+
+#ifdef GTEST_HAS_DEATH_TEST
+  g_argvs.clear();
+  for (int i = 0; i != *argc; i++) {
+    g_argvs.push_back(StreamableToString(argv[i]));
+  }
+#endif  // GTEST_HAS_DEATH_TEST
+
+  for (int i = 1; i != *argc; i++) {
+    const String arg_string = StreamableToString(argv[i]);
+    const char* const arg = arg_string.c_str();
+
+    using internal::ParseBoolFlag;
+    using internal::ParseInt32Flag;
+    using internal::ParseStringFlag;
+
+    // Do we see a Google Test flag?
+    if (ParseBoolFlag(arg, kBreakOnFailureFlag,
+                      &GTEST_FLAG(break_on_failure)) ||
+        ParseBoolFlag(arg, kCatchExceptionsFlag,
+                      &GTEST_FLAG(catch_exceptions)) ||
+        ParseStringFlag(arg, kColorFlag, &GTEST_FLAG(color)) ||
+        ParseStringFlag(arg, kDeathTestStyleFlag,
+                        &GTEST_FLAG(death_test_style)) ||
+        ParseStringFlag(arg, kFilterFlag, &GTEST_FLAG(filter)) ||
+        ParseStringFlag(arg, kInternalRunDeathTestFlag,
+                        &GTEST_FLAG(internal_run_death_test)) ||
+        ParseBoolFlag(arg, kListTestsFlag, &GTEST_FLAG(list_tests)) ||
+        ParseStringFlag(arg, kOutputFlag, &GTEST_FLAG(output)) ||
+        ParseInt32Flag(arg, kRepeatFlag, &GTEST_FLAG(repeat))
+        ) {
+      // Yes.  Shift the remainder of the argv list left by one.  Note
+      // that argv has (*argc + 1) elements, the last one always being
+      // NULL.  The following loop moves the trailing NULL element as
+      // well.
+      for (int j = i; j != *argc; j++) {
+        argv[j] = argv[j + 1];
+      }
+
+      // Decrements the argument count.
+      (*argc)--;
+
+      // We also need to decrement the iterator as we just removed
+      // an element.
+      i--;
+    }
+  }
+}
+
+}  // namespace internal
+
+// Initializes Google Test.  This must be called before calling
+// RUN_ALL_TESTS().  In particular, it parses a command line for the
+// flags that Google Test recognizes.  Whenever a Google Test flag is
+// seen, it is removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Test flag variables are
+// updated.
+void InitGoogleTest(int* argc, char** argv) {
+  internal::g_executable_path = argv[0];
+  internal::InitGoogleTestImpl(argc, argv);
+}
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+#ifdef GTEST_OS_WINDOWS
+void InitGoogleTest(int* argc, wchar_t** argv) {
+  // g_executable_path uses normal characters rather than wide chars, so call
+  // StreamableToString to convert argv[0] to normal characters (utf8 encoding).
+  internal::g_executable_path = internal::StreamableToString(argv[0]);
+  internal::InitGoogleTestImpl(argc, argv);
+}
+#endif  // GTEST_OS_WINDOWS
+
+}  // namespace testing
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest.h
new file mode 100644
index 0000000..2464f72
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest.h
@@ -0,0 +1,1216 @@
+// Copyright 2005, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file defines the public API for Google Test.  It should be
+// included by any test program that uses Google Test.
+//
+// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
+// leave some internal implementation details in this header file.
+// They are clearly marked by comments like this:
+//
+//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+//
+// Such code is NOT meant to be used by a user directly, and is subject
+// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
+// program!
+//
+// Acknowledgment: Google Test borrowed the idea of automatic test
+// registration from Barthelemy Dagenais' (barthelemy@prologique.com)
+// easyUnit framework.
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
+#define GTEST_INCLUDE_GTEST_GTEST_H_
+
+// The following platform macros are used throughout Google Test:
+//   _WIN32_WCE      Windows CE     (set in project files)
+//   __SYMBIAN32__   Symbian        (set by Symbian tool chain)
+//
+// Note that even though _MSC_VER and _WIN32_WCE really indicate a compiler
+// and a Win32 implementation, respectively, we use them to indicate the
+// combination of compiler - Win 32 API - C library, since the code currently
+// only supports:
+// Windows proper with Visual C++ and MS C library (_MSC_VER && !_WIN32_WCE) and
+// Windows Mobile with Visual C++ and no C library (_WIN32_WCE).
+
+#include <gtest/internal/gtest-internal.h>
+#include <gtest/internal/gtest-string.h>
+#include <gtest/gtest-death-test.h>
+#include <gtest/gtest-message.h>
+#include <gtest/gtest_prod.h>
+
+// Depending on the platform, different string classes are available.
+// On Windows, ::std::string compiles only when exceptions are
+// enabled.  On Linux, in addition to ::std::string, Google also makes
+// use of class ::string, which has the same interface as
+// ::std::string, but has a different implementation.
+//
+// The user can tell us whether ::std::string is available in his
+// environment by defining the macro GTEST_HAS_STD_STRING to either 1
+// or 0 on the compiler command line.  He can also define
+// GTEST_HAS_GLOBAL_STRING to 1 to indicate that ::string is available
+// AND is a distinct type to ::std::string, or define it to 0 to
+// indicate otherwise.
+//
+// If the user's ::std::string and ::string are the same class due to
+// aliasing, he should define GTEST_HAS_STD_STRING to 1 and
+// GTEST_HAS_GLOBAL_STRING to 0.
+//
+// If the user doesn't define GTEST_HAS_STD_STRING and/or
+// GTEST_HAS_GLOBAL_STRING, they are defined heuristically.
+
+namespace testing {
+
+// The upper limit for valid stack trace depths.
+const int kMaxStackTraceDepth = 100;
+
+// This flag specifies the maximum number of stack frames to be
+// printed in a failure message.
+GTEST_DECLARE_int32(stack_trace_depth);
+
+// This flag controls whether Google Test includes Google Test internal
+// stack frames in failure stack traces.
+GTEST_DECLARE_bool(show_internal_stack_frames);
+
+// The possible outcomes of a test part (i.e. an assertion or an
+// explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
+enum TestPartResultType {
+  TPRT_SUCCESS,           // Succeeded.
+  TPRT_NONFATAL_FAILURE,  // Failed but the test can continue.
+  TPRT_FATAL_FAILURE      // Failed and the test should be terminated.
+};
+
+namespace internal {
+
+class GTestFlagSaver;
+
+// Converts a streamable value to a String.  A NULL pointer is
+// converted to "(null)".  When the input value is a ::string,
+// ::std::string, ::wstring, or ::std::wstring object, each NUL
+// character in it is replaced with "\\0".
+// Declared in gtest-internal.h but defined here, so that it has access
+// to the definition of the Message class, required by the ARM
+// compiler.
+template <typename T>
+String StreamableToString(const T& streamable) {
+  return (Message() << streamable).GetString();
+}
+
+}  // namespace internal
+
+// A class for indicating whether an assertion was successful.  When
+// the assertion wasn't successful, the AssertionResult object
+// remembers a non-empty message that described how it failed.
+//
+// This class is useful for defining predicate-format functions to be
+// used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
+//
+// The constructor of AssertionResult is private.  To create an
+// instance of this class, use one of the factory functions
+// (AssertionSuccess() and AssertionFailure()).
+//
+// For example, in order to be able to write:
+//
+//   // Verifies that Foo() returns an even number.
+//   EXPECT_PRED_FORMAT1(IsEven, Foo());
+//
+// you just need to define:
+//
+//   testing::AssertionResult IsEven(const char* expr, int n) {
+//     if ((n % 2) == 0) return testing::AssertionSuccess();
+//
+//     Message msg;
+//     msg << "Expected: " << expr << " is even\n"
+//         << "  Actual: it's " << n;
+//     return testing::AssertionFailure(msg);
+//   }
+//
+// If Foo() returns 5, you will see the following message:
+//
+//   Expected: Foo() is even
+//     Actual: it's 5
+class AssertionResult {
+ public:
+  // Declares factory functions for making successful and failed
+  // assertion results as friends.
+  friend AssertionResult AssertionSuccess();
+  friend AssertionResult AssertionFailure(const Message&);
+
+  // Returns true iff the assertion succeeded.
+  operator bool() const { return failure_message_.c_str() == NULL; }  // NOLINT
+
+  // Returns the assertion's failure message.
+  const char* failure_message() const { return failure_message_.c_str(); }
+
+ private:
+  // The default constructor.  It is used when the assertion succeeded.
+  AssertionResult() {}
+
+  // The constructor used when the assertion failed.
+  explicit AssertionResult(const internal::String& failure_message);
+
+  // Stores the assertion's failure message.
+  internal::String failure_message_;
+};
+
+// Makes a successful assertion result.
+AssertionResult AssertionSuccess();
+
+// Makes a failed assertion result with the given failure message.
+AssertionResult AssertionFailure(const Message& msg);
+
+// The abstract class that all tests inherit from.
+//
+// In Google Test, a unit test program contains one or many TestCases, and
+// each TestCase contains one or many Tests.
+//
+// When you define a test using the TEST macro, you don't need to
+// explicitly derive from Test - the TEST macro automatically does
+// this for you.
+//
+// The only time you derive from Test is when defining a test fixture
+// to be used a TEST_F.  For example:
+//
+//   class FooTest : public testing::Test {
+//    protected:
+//     virtual void SetUp() { ... }
+//     virtual void TearDown() { ... }
+//     ...
+//   };
+//
+//   TEST_F(FooTest, Bar) { ... }
+//   TEST_F(FooTest, Baz) { ... }
+//
+// Test is not copyable.
+class Test {
+ public:
+  friend class internal::TestInfoImpl;
+
+  // Defines types for pointers to functions that set up and tear down
+  // a test case.
+  typedef void (*SetUpTestCaseFunc)();
+  typedef void (*TearDownTestCaseFunc)();
+
+  // The d'tor is virtual as we intend to inherit from Test.
+  virtual ~Test();
+
+  // Returns true iff the current test has a fatal failure.
+  static bool HasFatalFailure();
+
+  // Logs a property for the current test.  Only the last value for a given
+  // key is remembered.
+  // These are public static so they can be called from utility functions
+  // that are not members of the test fixture.
+  // The arguments are const char* instead strings, as Google Test is used
+  // on platforms where string doesn't compile.
+  //
+  // Note that a driving consideration for these RecordProperty methods
+  // was to produce xml output suited to the Greenspan charting utility,
+  // which at present will only chart values that fit in a 32-bit int. It
+  // is the user's responsibility to restrict their values to 32-bit ints
+  // if they intend them to be used with Greenspan.
+  static void RecordProperty(const char* key, const char* value);
+  static void RecordProperty(const char* key, int value);
+
+ protected:
+  // Creates a Test object.
+  Test();
+
+  // Sets up the stuff shared by all tests in this test case.
+  //
+  // Google Test will call Foo::SetUpTestCase() before running the first
+  // test in test case Foo.  Hence a sub-class can define its own
+  // SetUpTestCase() method to shadow the one defined in the super
+  // class.
+  static void SetUpTestCase() {}
+
+  // Tears down the stuff shared by all tests in this test case.
+  //
+  // Google Test will call Foo::TearDownTestCase() after running the last
+  // test in test case Foo.  Hence a sub-class can define its own
+  // TearDownTestCase() method to shadow the one defined in the super
+  // class.
+  static void TearDownTestCase() {}
+
+  // Sets up the test fixture.
+  virtual void SetUp();
+
+  // Tears down the test fixture.
+  virtual void TearDown();
+
+ private:
+  // Returns true iff the current test has the same fixture class as
+  // the first test in the current test case.
+  static bool HasSameFixtureClass();
+
+  // Runs the test after the test fixture has been set up.
+  //
+  // A sub-class must implement this to define the test logic.
+  //
+  // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM.
+  // Instead, use the TEST or TEST_F macro.
+  virtual void TestBody() = 0;
+
+  // Sets up, executes, and tears down the test.
+  void Run();
+
+  // Uses a GTestFlagSaver to save and restore all Google Test flags.
+  const internal::GTestFlagSaver* const gtest_flag_saver_;
+
+  // Often a user mis-spells SetUp() as Setup() and spends a long time
+  // wondering why it is never called by Google Test.  The declaration of
+  // the following method is solely for catching such an error at
+  // compile time:
+  //
+  //   - The return type is deliberately chosen to be not void, so it
+  //   will be a conflict if a user declares void Setup() in his test
+  //   fixture.
+  //
+  //   - This method is private, so it will be another compiler error
+  //   if a user calls it from his test fixture.
+  //
+  // DO NOT OVERRIDE THIS FUNCTION.
+  //
+  // If you see an error about overriding the following function or
+  // about it being private, you have mis-spelled SetUp() as Setup().
+  struct Setup_should_be_spelled_SetUp {};
+  virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
+
+  // We disallow copying Tests.
+  GTEST_DISALLOW_COPY_AND_ASSIGN(Test);
+};
+
+
+// Defines the type of a function pointer that creates a Test object
+// when invoked.
+typedef Test* (*TestMaker)();
+
+
+// A TestInfo object stores the following information about a test:
+//
+//   Test case name
+//   Test name
+//   Whether the test should be run
+//   A function pointer that creates the test object when invoked
+//   Test result
+//
+// The constructor of TestInfo registers itself with the UnitTest
+// singleton such that the RUN_ALL_TESTS() macro knows which tests to
+// run.
+class TestInfo {
+ public:
+  // Destructs a TestInfo object.  This function is not virtual, so
+  // don't inherit from TestInfo.
+  ~TestInfo();
+
+  // Creates a TestInfo object and registers it with the UnitTest
+  // singleton; returns the created object.
+  //
+  // Arguments:
+  //
+  //   test_case_name:   name of the test case
+  //   name:             name of the test
+  //   fixture_class_id: ID of the test fixture class
+  //   set_up_tc:        pointer to the function that sets up the test case
+  //   tear_down_tc:     pointer to the function that tears down the test case
+  //   maker:            pointer to the function that creates a test object
+  //
+  // This is public only because it's needed by the TEST and TEST_F macros.
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  static TestInfo* MakeAndRegisterInstance(
+      const char* test_case_name,
+      const char* name,
+      internal::TypeId fixture_class_id,
+      Test::SetUpTestCaseFunc set_up_tc,
+      Test::TearDownTestCaseFunc tear_down_tc,
+      TestMaker maker);
+
+  // Returns the test case name.
+  const char* test_case_name() const;
+
+  // Returns the test name.
+  const char* name() const;
+
+  // Returns true if this test should run.
+  //
+  // Google Test allows the user to filter the tests by their full names.
+  // The full name of a test Bar in test case Foo is defined as
+  // "Foo.Bar".  Only the tests that match the filter will run.
+  //
+  // A filter is a colon-separated list of glob (not regex) patterns,
+  // optionally followed by a '-' and a colon-separated list of
+  // negative patterns (tests to exclude).  A test is run if it
+  // matches one of the positive patterns and does not match any of
+  // the negative patterns.
+  //
+  // For example, *A*:Foo.* is a filter that matches any string that
+  // contains the character 'A' or starts with "Foo.".
+  bool should_run() const;
+
+  // Returns the result of the test.
+  const internal::TestResult* result() const;
+ private:
+#ifdef GTEST_HAS_DEATH_TEST
+  friend class internal::DefaultDeathTestFactory;
+#endif  // GTEST_HAS_DEATH_TEST
+  friend class internal::TestInfoImpl;
+  friend class internal::UnitTestImpl;
+  friend class Test;
+  friend class TestCase;
+
+  // Increments the number of death tests encountered in this test so
+  // far.
+  int increment_death_test_count();
+
+  // Accessors for the implementation object.
+  internal::TestInfoImpl* impl() { return impl_; }
+  const internal::TestInfoImpl* impl() const { return impl_; }
+
+  // Constructs a TestInfo object.
+  TestInfo(const char* test_case_name, const char* name,
+           internal::TypeId fixture_class_id, TestMaker maker);
+
+  // An opaque implementation object.
+  internal::TestInfoImpl* impl_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN(TestInfo);
+};
+
+// An Environment object is capable of setting up and tearing down an
+// environment.  The user should subclass this to define his own
+// environment(s).
+//
+// An Environment object does the set-up and tear-down in virtual
+// methods SetUp() and TearDown() instead of the constructor and the
+// destructor, as:
+//
+//   1. You cannot safely throw from a destructor.  This is a problem
+//      as in some cases Google Test is used where exceptions are enabled, and
+//      we may want to implement ASSERT_* using exceptions where they are
+//      available.
+//   2. You cannot use ASSERT_* directly in a constructor or
+//      destructor.
+class Environment {
+ public:
+  // The d'tor is virtual as we need to subclass Environment.
+  virtual ~Environment() {}
+
+  // Override this to define how to set up the environment.
+  virtual void SetUp() {}
+
+  // Override this to define how to tear down the environment.
+  virtual void TearDown() {}
+ private:
+  // If you see an error about overriding the following function or
+  // about it being private, you have mis-spelled SetUp() as Setup().
+  struct Setup_should_be_spelled_SetUp {};
+  virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
+};
+
+// A UnitTest consists of a list of TestCases.
+//
+// This is a singleton class.  The only instance of UnitTest is
+// created when UnitTest::GetInstance() is first called.  This
+// instance is never deleted.
+//
+// UnitTest is not copyable.
+//
+// This class is thread-safe as long as the methods are called
+// according to their specification.
+class UnitTest {
+ public:
+  // Gets the singleton UnitTest object.  The first time this method
+  // is called, a UnitTest object is constructed and returned.
+  // Consecutive calls will return the same object.
+  static UnitTest* GetInstance();
+
+  // Registers and returns a global test environment.  When a test
+  // program is run, all global test environments will be set-up in
+  // the order they were registered.  After all tests in the program
+  // have finished, all global test environments will be torn-down in
+  // the *reverse* order they were registered.
+  //
+  // The UnitTest object takes ownership of the given environment.
+  //
+  // This method can only be called from the main thread.
+  Environment* AddEnvironment(Environment* env);
+
+  // Adds a TestPartResult to the current TestResult object.  All
+  // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc)
+  // eventually call this to report their results.  The user code
+  // should use the assertion macros instead of calling this directly.
+  //
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  void AddTestPartResult(TestPartResultType result_type,
+                         const char* file_name,
+                         int line_number,
+                         const internal::String& message,
+                         const internal::String& os_stack_trace);
+
+  // Adds a TestProperty to the current TestResult object. If the result already
+  // contains a property with the same key, the value will be updated.
+  void RecordPropertyForCurrentTest(const char* key, const char* value);
+
+  // Runs all tests in this UnitTest object and prints the result.
+  // Returns 0 if successful, or 1 otherwise.
+  //
+  // This method can only be called from the main thread.
+  //
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  int Run() GTEST_MUST_USE_RESULT;
+
+  // Returns the TestCase object for the test that's currently running,
+  // or NULL if no test is running.
+  const TestCase* current_test_case() const;
+
+  // Returns the TestInfo object for the test that's currently running,
+  // or NULL if no test is running.
+  const TestInfo* current_test_info() const;
+
+  // Accessors for the implementation object.
+  internal::UnitTestImpl* impl() { return impl_; }
+  const internal::UnitTestImpl* impl() const { return impl_; }
+ private:
+  // ScopedTrace is a friend as it needs to modify the per-thread
+  // trace stack, which is a private member of UnitTest.
+  friend class internal::ScopedTrace;
+
+  // Creates an empty UnitTest.
+  UnitTest();
+
+  // D'tor
+  virtual ~UnitTest();
+
+  // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
+  // Google Test trace stack.
+  void PushGTestTrace(const internal::TraceInfo& trace);
+
+  // Pops a trace from the per-thread Google Test trace stack.
+  void PopGTestTrace();
+
+  // Protects mutable state in *impl_.  This is mutable as some const
+  // methods need to lock it too.
+  mutable internal::Mutex mutex_;
+
+  // Opaque implementation object.  This field is never changed once
+  // the object is constructed.  We don't mark it as const here, as
+  // doing so will cause a warning in the constructor of UnitTest.
+  // Mutable state in *impl_ is protected by mutex_.
+  internal::UnitTestImpl* impl_;
+
+  // We disallow copying UnitTest.
+  GTEST_DISALLOW_COPY_AND_ASSIGN(UnitTest);
+};
+
+// A convenient wrapper for adding an environment for the test
+// program.
+//
+// You should call this before RUN_ALL_TESTS() is called, probably in
+// main().  If you use gtest_main, you need to call this before main()
+// starts for it to take effect.  For example, you can define a global
+// variable like this:
+//
+//   testing::Environment* const foo_env =
+//       testing::AddGlobalTestEnvironment(new FooEnvironment);
+//
+// However, we strongly recommend you to write your own main() and
+// call AddGlobalTestEnvironment() there, as relying on initialization
+// of global variables makes the code harder to read and may cause
+// problems when you register multiple environments from different
+// translation units and the environments have dependencies among them
+// (remember that the compiler doesn't guarantee the order in which
+// global variables from different translation units are initialized).
+inline Environment* AddGlobalTestEnvironment(Environment* env) {
+  return UnitTest::GetInstance()->AddEnvironment(env);
+}
+
+// Initializes Google Test.  This must be called before calling
+// RUN_ALL_TESTS().  In particular, it parses a command line for the
+// flags that Google Test recognizes.  Whenever a Google Test flag is
+// seen, it is removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Test flag variables are
+// updated.
+void InitGoogleTest(int* argc, char** argv);
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+#ifdef GTEST_OS_WINDOWS
+void InitGoogleTest(int* argc, wchar_t** argv);
+#endif  // GTEST_OS_WINDOWS
+
+namespace internal {
+
+// These overloaded versions handle ::std::string and ::std::wstring.
+#if GTEST_HAS_STD_STRING
+inline String FormatForFailureMessage(const ::std::string& str) {
+  return (Message() << '"' << str << '"').GetString();
+}
+#endif  // GTEST_HAS_STD_STRING
+
+#if GTEST_HAS_STD_WSTRING
+inline String FormatForFailureMessage(const ::std::wstring& wstr) {
+  return (Message() << "L\"" << wstr << '"').GetString();
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+// These overloaded versions handle ::string and ::wstring.
+#if GTEST_HAS_GLOBAL_STRING
+inline String FormatForFailureMessage(const ::string& str) {
+  return (Message() << '"' << str << '"').GetString();
+}
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+#if GTEST_HAS_GLOBAL_WSTRING
+inline String FormatForFailureMessage(const ::wstring& wstr) {
+  return (Message() << "L\"" << wstr << '"').GetString();
+}
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
+// operand to be used in a failure message.  The type (but not value)
+// of the other operand may affect the format.  This allows us to
+// print a char* as a raw pointer when it is compared against another
+// char*, and print it as a C string when it is compared against an
+// std::string object, for example.
+//
+// The default implementation ignores the type of the other operand.
+// Some specialized versions are used to handle formatting wide or
+// narrow C strings.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+template <typename T1, typename T2>
+String FormatForComparisonFailureMessage(const T1& value,
+                                         const T2& /* other_operand */) {
+  return FormatForFailureMessage(value);
+}
+
+// The helper function for {ASSERT|EXPECT}_EQ.
+template <typename T1, typename T2>
+AssertionResult CmpHelperEQ(const char* expected_expression,
+                            const char* actual_expression,
+                            const T1& expected,
+                            const T2& actual) {
+  if (expected == actual) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(expected_expression,
+                   actual_expression,
+                   FormatForComparisonFailureMessage(expected, actual),
+                   FormatForComparisonFailureMessage(actual, expected),
+                   false);
+}
+
+// With this overloaded version, we allow anonymous enums to be used
+// in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums
+// can be implicitly cast to BiggestInt.
+AssertionResult CmpHelperEQ(const char* expected_expression,
+                            const char* actual_expression,
+                            BiggestInt expected,
+                            BiggestInt actual);
+
+// The helper class for {ASSERT|EXPECT}_EQ.  The template argument
+// lhs_is_null_literal is true iff the first argument to ASSERT_EQ()
+// is a null pointer literal.  The following default implementation is
+// for lhs_is_null_literal being false.
+template <bool lhs_is_null_literal>
+class EqHelper {
+ public:
+  // This templatized version is for the general case.
+  template <typename T1, typename T2>
+  static AssertionResult Compare(const char* expected_expression,
+                                 const char* actual_expression,
+                                 const T1& expected,
+                                 const T2& actual) {
+    return CmpHelperEQ(expected_expression, actual_expression, expected,
+                       actual);
+  }
+
+  // With this overloaded version, we allow anonymous enums to be used
+  // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous
+  // enums can be implicitly cast to BiggestInt.
+  //
+  // Even though its body looks the same as the above version, we
+  // cannot merge the two, as it will make anonymous enums unhappy.
+  static AssertionResult Compare(const char* expected_expression,
+                                 const char* actual_expression,
+                                 BiggestInt expected,
+                                 BiggestInt actual) {
+    return CmpHelperEQ(expected_expression, actual_expression, expected,
+                       actual);
+  }
+};
+
+// This specialization is used when the first argument to ASSERT_EQ()
+// is a null pointer literal.
+template <>
+class EqHelper<true> {
+ public:
+  // We define two overloaded versions of Compare().  The first
+  // version will be picked when the second argument to ASSERT_EQ() is
+  // NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or
+  // EXPECT_EQ(false, a_bool).
+  template <typename T1, typename T2>
+  static AssertionResult Compare(const char* expected_expression,
+                                 const char* actual_expression,
+                                 const T1& expected,
+                                 const T2& actual) {
+    return CmpHelperEQ(expected_expression, actual_expression, expected,
+                       actual);
+  }
+
+  // This version will be picked when the second argument to
+  // ASSERT_EQ() is a pointer, e.g. ASSERT_EQ(NULL, a_pointer).
+  template <typename T1, typename T2>
+  static AssertionResult Compare(const char* expected_expression,
+                                 const char* actual_expression,
+                                 const T1& expected,
+                                 T2* actual) {
+    // We already know that 'expected' is a null pointer.
+    return CmpHelperEQ(expected_expression, actual_expression,
+                       static_cast<T2*>(NULL), actual);
+  }
+};
+
+// A macro for implementing the helper functions needed to implement
+// ASSERT_?? and EXPECT_??.  It is here just to avoid copy-and-paste
+// of similar code.
+//
+// For each templatized helper function, we also define an overloaded
+// version for BiggestInt in order to reduce code bloat and allow
+// anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled
+// with gcc 4.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+#define GTEST_IMPL_CMP_HELPER(op_name, op)\
+template <typename T1, typename T2>\
+AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
+                                   const T1& val1, const T2& val2) {\
+  if (val1 op val2) {\
+    return AssertionSuccess();\
+  } else {\
+    Message msg;\
+    msg << "Expected: (" << expr1 << ") " #op " (" << expr2\
+        << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
+        << " vs " << FormatForComparisonFailureMessage(val2, val1);\
+    return AssertionFailure(msg);\
+  }\
+}\
+AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
+                                   BiggestInt val1, BiggestInt val2);
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+
+// Implements the helper function for {ASSERT|EXPECT}_NE
+GTEST_IMPL_CMP_HELPER(NE, !=)
+// Implements the helper function for {ASSERT|EXPECT}_LE
+GTEST_IMPL_CMP_HELPER(LE, <=)
+// Implements the helper function for {ASSERT|EXPECT}_LT
+GTEST_IMPL_CMP_HELPER(LT, < )
+// Implements the helper function for {ASSERT|EXPECT}_GE
+GTEST_IMPL_CMP_HELPER(GE, >=)
+// Implements the helper function for {ASSERT|EXPECT}_GT
+GTEST_IMPL_CMP_HELPER(GT, > )
+
+#undef GTEST_IMPL_CMP_HELPER
+
+// The helper function for {ASSERT|EXPECT}_STREQ.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+AssertionResult CmpHelperSTREQ(const char* expected_expression,
+                               const char* actual_expression,
+                               const char* expected,
+                               const char* actual);
+
+// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression,
+                                   const char* actual_expression,
+                                   const char* expected,
+                                   const char* actual);
+
+// The helper function for {ASSERT|EXPECT}_STRNE.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                               const char* s2_expression,
+                               const char* s1,
+                               const char* s2);
+
+// The helper function for {ASSERT|EXPECT}_STRCASENE.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
+                                   const char* s2_expression,
+                                   const char* s1,
+                                   const char* s2);
+
+
+// Helper function for *_STREQ on wide strings.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+AssertionResult CmpHelperSTREQ(const char* expected_expression,
+                               const char* actual_expression,
+                               const wchar_t* expected,
+                               const wchar_t* actual);
+
+// Helper function for *_STRNE on wide strings.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                               const char* s2_expression,
+                               const wchar_t* s1,
+                               const wchar_t* s2);
+
+}  // namespace internal
+
+// IsSubstring() and IsNotSubstring() are intended to be used as the
+// first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by
+// themselves.  They check whether needle is a substring of haystack
+// (NULL is considered a substring of itself only), and return an
+// appropriate error message when they fail.
+//
+// The {needle,haystack}_expr arguments are the stringified
+// expressions that generated the two real arguments.
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack);
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack);
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack);
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack);
+#if GTEST_HAS_STD_STRING
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack);
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack);
+#endif  // GTEST_HAS_STD_STRING
+
+#if GTEST_HAS_STD_WSTRING
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack);
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack);
+#endif  // GTEST_HAS_STD_WSTRING
+
+namespace internal {
+
+// Helper template function for comparing floating-points.
+//
+// Template parameter:
+//
+//   RawType: the raw floating-point type (either float or double)
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+template <typename RawType>
+AssertionResult CmpHelperFloatingPointEQ(const char* expected_expression,
+                                         const char* actual_expression,
+                                         RawType expected,
+                                         RawType actual) {
+  const FloatingPoint<RawType> lhs(expected), rhs(actual);
+
+  if (lhs.AlmostEquals(rhs)) {
+    return AssertionSuccess();
+  }
+
+  StrStream expected_ss;
+  expected_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+              << expected;
+
+  StrStream actual_ss;
+  actual_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+            << actual;
+
+  return EqFailure(expected_expression,
+                   actual_expression,
+                   StrStreamToString(&expected_ss),
+                   StrStreamToString(&actual_ss),
+                   false);
+}
+
+// Helper function for implementing ASSERT_NEAR.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+AssertionResult DoubleNearPredFormat(const char* expr1,
+                                     const char* expr2,
+                                     const char* abs_error_expr,
+                                     double val1,
+                                     double val2,
+                                     double abs_error);
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+// A class that enables one to stream messages to assertion macros
+class AssertHelper {
+ public:
+  // Constructor.
+  AssertHelper(TestPartResultType type, const char* file, int line,
+               const char* message);
+  // Message assignment is a semantic trick to enable assertion
+  // streaming; see the GTEST_MESSAGE macro below.
+  void operator=(const Message& message) const;
+ private:
+  TestPartResultType const type_;
+  const char*        const file_;
+  int                const line_;
+  String             const message_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN(AssertHelper);
+};
+
+}  // namespace internal
+
+// Macros for indicating success/failure in test code.
+
+// ADD_FAILURE unconditionally adds a failure to the current test.
+// SUCCEED generates a success - it doesn't automatically make the
+// current test successful, as a test is only successful when it has
+// no failure.
+//
+// EXPECT_* verifies that a certain condition is satisfied.  If not,
+// it behaves like ADD_FAILURE.  In particular:
+//
+//   EXPECT_TRUE  verifies that a Boolean condition is true.
+//   EXPECT_FALSE verifies that a Boolean condition is false.
+//
+// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except
+// that they will also abort the current function on failure.  People
+// usually want the fail-fast behavior of FAIL and ASSERT_*, but those
+// writing data-driven tests often find themselves using ADD_FAILURE
+// and EXPECT_* more.
+//
+// Examples:
+//
+//   EXPECT_TRUE(server.StatusIsOK());
+//   ASSERT_FALSE(server.HasPendingRequest(port))
+//       << "There are still pending requests " << "on port " << port;
+
+// Generates a nonfatal failure with a generic message.
+#define ADD_FAILURE() GTEST_NONFATAL_FAILURE("Failed")
+
+// Generates a fatal failure with a generic message.
+#define FAIL() GTEST_FATAL_FAILURE("Failed")
+
+// Generates a success with a generic message.
+#define SUCCEED() GTEST_SUCCESS("Succeeded")
+
+// Boolean assertions.
+#define EXPECT_TRUE(condition) \
+  GTEST_TEST_BOOLEAN(condition, #condition, false, true, \
+                     GTEST_NONFATAL_FAILURE)
+#define EXPECT_FALSE(condition) \
+  GTEST_TEST_BOOLEAN(!(condition), #condition, true, false, \
+                     GTEST_NONFATAL_FAILURE)
+#define ASSERT_TRUE(condition) \
+  GTEST_TEST_BOOLEAN(condition, #condition, false, true, \
+                     GTEST_FATAL_FAILURE)
+#define ASSERT_FALSE(condition) \
+  GTEST_TEST_BOOLEAN(!(condition), #condition, true, false, \
+                     GTEST_FATAL_FAILURE)
+
+// Includes the auto-generated header that implements a family of
+// generic predicate assertion macros.
+#include <gtest/gtest_pred_impl.h>
+
+// Macros for testing equalities and inequalities.
+//
+//    * {ASSERT|EXPECT}_EQ(expected, actual): Tests that expected == actual
+//    * {ASSERT|EXPECT}_NE(v1, v2):           Tests that v1 != v2
+//    * {ASSERT|EXPECT}_LT(v1, v2):           Tests that v1 < v2
+//    * {ASSERT|EXPECT}_LE(v1, v2):           Tests that v1 <= v2
+//    * {ASSERT|EXPECT}_GT(v1, v2):           Tests that v1 > v2
+//    * {ASSERT|EXPECT}_GE(v1, v2):           Tests that v1 >= v2
+//
+// When they are not, Google Test prints both the tested expressions and
+// their actual values.  The values must be compatible built-in types,
+// or you will get a compiler error.  By "compatible" we mean that the
+// values can be compared by the respective operator.
+//
+// Note:
+//
+//   1. It is possible to make a user-defined type work with
+//   {ASSERT|EXPECT}_??(), but that requires overloading the
+//   comparison operators and is thus discouraged by the Google C++
+//   Usage Guide.  Therefore, you are advised to use the
+//   {ASSERT|EXPECT}_TRUE() macro to assert that two objects are
+//   equal.
+//
+//   2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on
+//   pointers (in particular, C strings).  Therefore, if you use it
+//   with two C strings, you are testing how their locations in memory
+//   are related, not how their content is related.  To compare two C
+//   strings by content, use {ASSERT|EXPECT}_STR*().
+//
+//   3. {ASSERT|EXPECT}_EQ(expected, actual) is preferred to
+//   {ASSERT|EXPECT}_TRUE(expected == actual), as the former tells you
+//   what the actual value is when it fails, and similarly for the
+//   other comparisons.
+//
+//   4. Do not depend on the order in which {ASSERT|EXPECT}_??()
+//   evaluate their arguments, which is undefined.
+//
+//   5. These macros evaluate their arguments exactly once.
+//
+// Examples:
+//
+//   EXPECT_NE(5, Foo());
+//   EXPECT_EQ(NULL, a_pointer);
+//   ASSERT_LT(i, array_size);
+//   ASSERT_GT(records.size(), 0) << "There is no record left.";
+
+#define EXPECT_EQ(expected, actual) \
+  EXPECT_PRED_FORMAT2(::testing::internal:: \
+                      EqHelper<GTEST_IS_NULL_LITERAL(expected)>::Compare, \
+                      expected, actual)
+#define EXPECT_NE(expected, actual) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, expected, actual)
+#define EXPECT_LE(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
+#define EXPECT_LT(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
+#define EXPECT_GE(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
+#define EXPECT_GT(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
+
+#define ASSERT_EQ(expected, actual) \
+  ASSERT_PRED_FORMAT2(::testing::internal:: \
+                      EqHelper<GTEST_IS_NULL_LITERAL(expected)>::Compare, \
+                      expected, actual)
+#define ASSERT_NE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
+#define ASSERT_LE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
+#define ASSERT_LT(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
+#define ASSERT_GE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
+#define ASSERT_GT(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
+
+// C String Comparisons.  All tests treat NULL and any non-NULL string
+// as different.  Two NULLs are equal.
+//
+//    * {ASSERT|EXPECT}_STREQ(s1, s2):     Tests that s1 == s2
+//    * {ASSERT|EXPECT}_STRNE(s1, s2):     Tests that s1 != s2
+//    * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case
+//    * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case
+//
+// For wide or narrow string objects, you can use the
+// {ASSERT|EXPECT}_??() macros.
+//
+// Don't depend on the order in which the arguments are evaluated,
+// which is undefined.
+//
+// These macros evaluate their arguments exactly once.
+
+#define EXPECT_STREQ(expected, actual) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual)
+#define EXPECT_STRNE(s1, s2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
+#define EXPECT_STRCASEEQ(expected, actual) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual)
+#define EXPECT_STRCASENE(s1, s2)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
+
+#define ASSERT_STREQ(expected, actual) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual)
+#define ASSERT_STRNE(s1, s2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
+#define ASSERT_STRCASEEQ(expected, actual) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual)
+#define ASSERT_STRCASENE(s1, s2)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
+
+// Macros for comparing floating-point numbers.
+//
+//    * {ASSERT|EXPECT}_FLOAT_EQ(expected, actual):
+//         Tests that two float values are almost equal.
+//    * {ASSERT|EXPECT}_DOUBLE_EQ(expected, actual):
+//         Tests that two double values are almost equal.
+//    * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error):
+//         Tests that v1 and v2 are within the given distance to each other.
+//
+// Google Test uses ULP-based comparison to automatically pick a default
+// error bound that is appropriate for the operands.  See the
+// FloatingPoint template class in gtest-internal.h if you are
+// interested in the implementation details.
+
+#define EXPECT_FLOAT_EQ(expected, actual)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
+                      expected, actual)
+
+#define EXPECT_DOUBLE_EQ(expected, actual)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
+                      expected, actual)
+
+#define ASSERT_FLOAT_EQ(expected, actual)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
+                      expected, actual)
+
+#define ASSERT_DOUBLE_EQ(expected, actual)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
+                      expected, actual)
+
+#define EXPECT_NEAR(val1, val2, abs_error)\
+  EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
+                      val1, val2, abs_error)
+
+#define ASSERT_NEAR(val1, val2, abs_error)\
+  ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
+                      val1, val2, abs_error)
+
+// These predicate format functions work on floating-point values, and
+// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g.
+//
+//   EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0);
+
+// Asserts that val1 is less than, or almost equal to, val2.  Fails
+// otherwise.  In particular, it fails if either val1 or val2 is NaN.
+AssertionResult FloatLE(const char* expr1, const char* expr2,
+                        float val1, float val2);
+AssertionResult DoubleLE(const char* expr1, const char* expr2,
+                         double val1, double val2);
+
+
+#ifdef GTEST_OS_WINDOWS
+
+// Macros that test for HRESULT failure and success, these are only useful
+// on Windows, and rely on Windows SDK macros and APIs to compile.
+//
+//    * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr)
+//
+// When expr unexpectedly fails or succeeds, Google Test prints the expected result
+// and the actual result with both a human-readable string representation of
+// the error, if available, as well as the hex result code.
+#define EXPECT_HRESULT_SUCCEEDED(expr) \
+    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
+
+#define ASSERT_HRESULT_SUCCEEDED(expr) \
+    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
+
+#define EXPECT_HRESULT_FAILED(expr) \
+    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
+
+#define ASSERT_HRESULT_FAILED(expr) \
+    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
+
+#endif  // GTEST_OS_WINDOWS
+
+
+// Causes a trace (including the source file path, the current line
+// number, and the given message) to be included in every test failure
+// message generated by code in the current scope.  The effect is
+// undone when the control leaves the current scope.
+//
+// The message argument can be anything streamable to std::ostream.
+//
+// In the implementation, we include the current line number as part
+// of the dummy variable name, thus allowing multiple SCOPED_TRACE()s
+// to appear in the same block - as long as they are on different
+// lines.
+#define SCOPED_TRACE(message) \
+  ::testing::internal::ScopedTrace GTEST_CONCAT_TOKEN(gtest_trace_, __LINE__)(\
+    __FILE__, __LINE__, ::testing::Message() << (message))
+
+
+// Defines a test.
+//
+// The first parameter is the name of the test case, and the second
+// parameter is the name of the test within the test case.
+//
+// The convention is to end the test case name with "Test".  For
+// example, a test case for the Foo class can be named FooTest.
+//
+// The user should put his test code between braces after using this
+// macro.  Example:
+//
+//   TEST(FooTest, InitializesCorrectly) {
+//     Foo foo;
+//     EXPECT_TRUE(foo.StatusIsOK());
+//   }
+
+#define TEST(test_case_name, test_name)\
+  GTEST_TEST(test_case_name, test_name, ::testing::Test)
+
+
+// Defines a test that uses a test fixture.
+//
+// The first parameter is the name of the test fixture class, which
+// also doubles as the test case name.  The second parameter is the
+// name of the test within the test case.
+//
+// A test fixture class must be declared earlier.  The user should put
+// his test code between braces after using this macro.  Example:
+//
+//   class FooTest : public testing::Test {
+//    protected:
+//     virtual void SetUp() { b_.AddElement(3); }
+//
+//     Foo a_;
+//     Foo b_;
+//   };
+//
+//   TEST_F(FooTest, InitializesCorrectly) {
+//     EXPECT_TRUE(a_.StatusIsOK());
+//   }
+//
+//   TEST_F(FooTest, ReturnsElementCountCorrectly) {
+//     EXPECT_EQ(0, a_.size());
+//     EXPECT_EQ(1, b_.size());
+//   }
+
+#define TEST_F(test_fixture, test_name)\
+  GTEST_TEST(test_fixture, test_name, test_fixture)
+
+// Use this macro in main() to run all tests.  It returns 0 if all
+// tests are successful, or 1 otherwise.
+//
+// RUN_ALL_TESTS() should be invoked after the command line has been
+// parsed by InitGoogleTest().
+
+#define RUN_ALL_TESTS()\
+  (::testing::UnitTest::GetInstance()->Run())
+
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest_main.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest_main.cc
new file mode 100644
index 0000000..d20c02fd
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest_main.cc
@@ -0,0 +1,39 @@
+// Copyright 2006, 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 <iostream>
+
+#include <gtest/gtest.h>
+
+int main(int argc, char **argv) {
+  std::cout << "Running main() from gtest_main.cc\n";
+
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest_pred_impl.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest_pred_impl.h
new file mode 100644
index 0000000..984f793
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest_pred_impl.h
@@ -0,0 +1,368 @@
+// Copyright 2006, 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.
+
+// This file is AUTOMATICALLY GENERATED on 06/22/2008 by command
+// 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
+//
+// Implements a family of generic predicate assertion macros.
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+#define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+
+// Makes sure this header is not included before gtest.h.
+#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
+#error Do not include gtest_pred_impl.h directly.  Include gtest.h instead.
+#endif  // GTEST_INCLUDE_GTEST_GTEST_H_
+
+// This header implements a family of generic predicate assertion
+// macros:
+//
+//   ASSERT_PRED_FORMAT1(pred_format, v1)
+//   ASSERT_PRED_FORMAT2(pred_format, v1, v2)
+//   ...
+//
+// where pred_format is a function or functor that takes n (in the
+// case of ASSERT_PRED_FORMATn) values and their source expression
+// text, and returns a testing::AssertionResult.  See the definition
+// of ASSERT_EQ in gtest.h for an example.
+//
+// If you don't care about formatting, you can use the more
+// restrictive version:
+//
+//   ASSERT_PRED1(pred, v1)
+//   ASSERT_PRED2(pred, v1, v2)
+//   ...
+//
+// where pred is an n-ary function or functor that returns bool,
+// and the values v1, v2, ..., must support the << operator for
+// streaming to std::ostream.
+//
+// We also define the EXPECT_* variations.
+//
+// For now we only support predicates whose arity is at most 5.
+// Please email googletestframework@googlegroups.com if you need
+// support for higher arities.
+
+// GTEST_ASSERT is the basic statement to which all of the assertions
+// in this file reduce.  Don't use this in your code.
+
+#define GTEST_ASSERT(expression, on_failure) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER \
+  if (const ::testing::AssertionResult gtest_ar = (expression)) \
+    ; \
+  else \
+    on_failure(gtest_ar.failure_message())
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED1.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1>
+AssertionResult AssertPred1Helper(const char* pred_text,
+                                  const char* e1,
+                                  Pred pred,
+                                  const T1& v1) {
+  if (pred(v1)) return AssertionSuccess();
+
+  Message msg;
+  msg << pred_text << "("
+      << e1 << ") evaluates to false, where"
+      << "\n" << e1 << " evaluates to " << v1;
+  return AssertionFailure(msg);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT1(pred_format, v1, on_failure)\
+  GTEST_ASSERT(pred_format(#v1, v1),\
+               on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED1.  Don't use
+// this in your code.
+#define GTEST_PRED1(pred, v1, on_failure)\
+  GTEST_ASSERT(::testing::AssertPred1Helper(#pred, \
+                                 #v1, \
+                                 pred, \
+                                 v1), on_failure)
+
+// Unary predicate assertion macros.
+#define EXPECT_PRED_FORMAT1(pred_format, v1) \
+  GTEST_PRED_FORMAT1(pred_format, v1, GTEST_NONFATAL_FAILURE)
+#define EXPECT_PRED1(pred, v1) \
+  GTEST_PRED1(pred, v1, GTEST_NONFATAL_FAILURE)
+#define ASSERT_PRED_FORMAT1(pred_format, v1) \
+  GTEST_PRED_FORMAT1(pred_format, v1, GTEST_FATAL_FAILURE)
+#define ASSERT_PRED1(pred, v1) \
+  GTEST_PRED1(pred, v1, GTEST_FATAL_FAILURE)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED2.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2>
+AssertionResult AssertPred2Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2) {
+  if (pred(v1, v2)) return AssertionSuccess();
+
+  Message msg;
+  msg << pred_text << "("
+      << e1 << ", "
+      << e2 << ") evaluates to false, where"
+      << "\n" << e1 << " evaluates to " << v1
+      << "\n" << e2 << " evaluates to " << v2;
+  return AssertionFailure(msg);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT2(pred_format, v1, v2, on_failure)\
+  GTEST_ASSERT(pred_format(#v1, #v2, v1, v2),\
+               on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED2.  Don't use
+// this in your code.
+#define GTEST_PRED2(pred, v1, v2, on_failure)\
+  GTEST_ASSERT(::testing::AssertPred2Helper(#pred, \
+                                 #v1, \
+                                 #v2, \
+                                 pred, \
+                                 v1, \
+                                 v2), on_failure)
+
+// Binary predicate assertion macros.
+#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \
+  GTEST_PRED_FORMAT2(pred_format, v1, v2, GTEST_NONFATAL_FAILURE)
+#define EXPECT_PRED2(pred, v1, v2) \
+  GTEST_PRED2(pred, v1, v2, GTEST_NONFATAL_FAILURE)
+#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \
+  GTEST_PRED_FORMAT2(pred_format, v1, v2, GTEST_FATAL_FAILURE)
+#define ASSERT_PRED2(pred, v1, v2) \
+  GTEST_PRED2(pred, v1, v2, GTEST_FATAL_FAILURE)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED3.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3>
+AssertionResult AssertPred3Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  const T3& v3) {
+  if (pred(v1, v2, v3)) return AssertionSuccess();
+
+  Message msg;
+  msg << pred_text << "("
+      << e1 << ", "
+      << e2 << ", "
+      << e3 << ") evaluates to false, where"
+      << "\n" << e1 << " evaluates to " << v1
+      << "\n" << e2 << " evaluates to " << v2
+      << "\n" << e3 << " evaluates to " << v3;
+  return AssertionFailure(msg);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT3(pred_format, v1, v2, v3, on_failure)\
+  GTEST_ASSERT(pred_format(#v1, #v2, #v3, v1, v2, v3),\
+               on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED3.  Don't use
+// this in your code.
+#define GTEST_PRED3(pred, v1, v2, v3, on_failure)\
+  GTEST_ASSERT(::testing::AssertPred3Helper(#pred, \
+                                 #v1, \
+                                 #v2, \
+                                 #v3, \
+                                 pred, \
+                                 v1, \
+                                 v2, \
+                                 v3), on_failure)
+
+// Ternary predicate assertion macros.
+#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \
+  GTEST_PRED_FORMAT3(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE)
+#define EXPECT_PRED3(pred, v1, v2, v3) \
+  GTEST_PRED3(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE)
+#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \
+  GTEST_PRED_FORMAT3(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE)
+#define ASSERT_PRED3(pred, v1, v2, v3) \
+  GTEST_PRED3(pred, v1, v2, v3, GTEST_FATAL_FAILURE)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED4.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4>
+AssertionResult AssertPred4Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  const char* e4,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  const T3& v3,
+                                  const T4& v4) {
+  if (pred(v1, v2, v3, v4)) return AssertionSuccess();
+
+  Message msg;
+  msg << pred_text << "("
+      << e1 << ", "
+      << e2 << ", "
+      << e3 << ", "
+      << e4 << ") evaluates to false, where"
+      << "\n" << e1 << " evaluates to " << v1
+      << "\n" << e2 << " evaluates to " << v2
+      << "\n" << e3 << " evaluates to " << v3
+      << "\n" << e4 << " evaluates to " << v4;
+  return AssertionFailure(msg);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT4(pred_format, v1, v2, v3, v4, on_failure)\
+  GTEST_ASSERT(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4),\
+               on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED4.  Don't use
+// this in your code.
+#define GTEST_PRED4(pred, v1, v2, v3, v4, on_failure)\
+  GTEST_ASSERT(::testing::AssertPred4Helper(#pred, \
+                                 #v1, \
+                                 #v2, \
+                                 #v3, \
+                                 #v4, \
+                                 pred, \
+                                 v1, \
+                                 v2, \
+                                 v3, \
+                                 v4), on_failure)
+
+// 4-ary predicate assertion macros.
+#define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
+  GTEST_PRED_FORMAT4(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE)
+#define EXPECT_PRED4(pred, v1, v2, v3, v4) \
+  GTEST_PRED4(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE)
+#define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
+  GTEST_PRED_FORMAT4(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE)
+#define ASSERT_PRED4(pred, v1, v2, v3, v4) \
+  GTEST_PRED4(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED5.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5>
+AssertionResult AssertPred5Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  const char* e4,
+                                  const char* e5,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  const T3& v3,
+                                  const T4& v4,
+                                  const T5& v5) {
+  if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess();
+
+  Message msg;
+  msg << pred_text << "("
+      << e1 << ", "
+      << e2 << ", "
+      << e3 << ", "
+      << e4 << ", "
+      << e5 << ") evaluates to false, where"
+      << "\n" << e1 << " evaluates to " << v1
+      << "\n" << e2 << " evaluates to " << v2
+      << "\n" << e3 << " evaluates to " << v3
+      << "\n" << e4 << " evaluates to " << v4
+      << "\n" << e5 << " evaluates to " << v5;
+  return AssertionFailure(msg);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5, on_failure)\
+  GTEST_ASSERT(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5),\
+               on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED5.  Don't use
+// this in your code.
+#define GTEST_PRED5(pred, v1, v2, v3, v4, v5, on_failure)\
+  GTEST_ASSERT(::testing::AssertPred5Helper(#pred, \
+                                 #v1, \
+                                 #v2, \
+                                 #v3, \
+                                 #v4, \
+                                 #v5, \
+                                 pred, \
+                                 v1, \
+                                 v2, \
+                                 v3, \
+                                 v4, \
+                                 v5), on_failure)
+
+// 5-ary predicate assertion macros.
+#define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
+  GTEST_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE)
+#define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \
+  GTEST_PRED5(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE)
+#define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
+  GTEST_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE)
+#define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \
+  GTEST_PRED5(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE)
+
+
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest_prod.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest_prod.h
new file mode 100644
index 0000000..da80ddc
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/gtest_prod.h
@@ -0,0 +1,58 @@
+// Copyright 2006, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// Google C++ Testing Framework definitions useful in production code.
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_PROD_H_
+#define GTEST_INCLUDE_GTEST_GTEST_PROD_H_
+
+// When you need to test the private or protected members of a class,
+// use the FRIEND_TEST macro to declare your tests as friends of the
+// class.  For example:
+//
+// class MyClass {
+//  private:
+//   void MyMethod();
+//   FRIEND_TEST(MyClassTest, MyMethod);
+// };
+//
+// class MyClassTest : public testing::Test {
+//   // ...
+// };
+//
+// TEST_F(MyClassTest, MyMethod) {
+//   // Can call MyClass::MyMethod() here.
+// }
+
+#define FRIEND_TEST(test_case_name, test_name)\
+friend class test_case_name##_##test_name##_Test
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_PROD_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/internal/gtest-death-test-internal.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/internal/gtest-death-test-internal.h
new file mode 100644
index 0000000..b49c6e4
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/internal/gtest-death-test-internal.h
@@ -0,0 +1,201 @@
+// Copyright 2005, 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.
+//
+// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file defines internal utilities needed for implementing
+// death tests.  They are subject to change without notice.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
+
+#include <gtest/internal/gtest-internal.h>
+
+namespace testing {
+namespace internal {
+
+GTEST_DECLARE_string(internal_run_death_test);
+
+// Names of the flags (needed for parsing Google Test flags).
+const char kDeathTestStyleFlag[] = "death_test_style";
+const char kInternalRunDeathTestFlag[] = "internal_run_death_test";
+
+#ifdef GTEST_HAS_DEATH_TEST
+
+// DeathTest is a class that hides much of the complexity of the
+// GTEST_DEATH_TEST macro.  It is abstract; its static Create method
+// returns a concrete class that depends on the prevailing death test
+// style, as defined by the --gtest_death_test_style and/or
+// --gtest_internal_run_death_test flags.
+
+// In describing the results of death tests, these terms are used with
+// the corresponding definitions:
+//
+// exit status:  The integer exit information in the format specified
+//               by wait(2)
+// exit code:    The integer code passed to exit(3), _exit(2), or
+//               returned from main()
+class DeathTest {
+ public:
+  // Create returns false if there was an error determining the
+  // appropriate action to take for the current death test; for example,
+  // if the gtest_death_test_style flag is set to an invalid value.
+  // The LastMessage method will return a more detailed message in that
+  // case.  Otherwise, the DeathTest pointer pointed to by the "test"
+  // argument is set.  If the death test should be skipped, the pointer
+  // is set to NULL; otherwise, it is set to the address of a new concrete
+  // DeathTest object that controls the execution of the current test.
+  static bool Create(const char* statement, const RE* regex,
+                     const char* file, int line, DeathTest** test);
+  DeathTest();
+  virtual ~DeathTest() { }
+
+  // A helper class that aborts a death test when it's deleted.
+  class ReturnSentinel {
+   public:
+    explicit ReturnSentinel(DeathTest* test) : test_(test) { }
+    ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); }
+   private:
+    DeathTest* const test_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN(ReturnSentinel);
+  } GTEST_ATTRIBUTE_UNUSED;
+
+  // An enumeration of possible roles that may be taken when a death
+  // test is encountered.  EXECUTE means that the death test logic should
+  // be executed immediately.  OVERSEE means that the program should prepare
+  // the appropriate environment for a child process to execute the death
+  // test, then wait for it to complete.
+  enum TestRole { OVERSEE_TEST, EXECUTE_TEST };
+
+  // An enumeration of the two reasons that a test might be aborted.
+  enum AbortReason { TEST_ENCOUNTERED_RETURN_STATEMENT, TEST_DID_NOT_DIE };
+
+  // Assumes one of the above roles.
+  virtual TestRole AssumeRole() = 0;
+
+  // Waits for the death test to finish and returns its status.
+  virtual int Wait() = 0;
+
+  // Returns true if the death test passed; that is, the test process
+  // exited during the test, its exit status matches a user-supplied
+  // predicate, and its stderr output matches a user-supplied regular
+  // expression.
+  // The user-supplied predicate may be a macro expression rather
+  // than a function pointer or functor, or else Wait and Passed could
+  // be combined.
+  virtual bool Passed(bool exit_status_ok) = 0;
+
+  // Signals that the death test did not die as expected.
+  virtual void Abort(AbortReason reason) = 0;
+
+  // Returns a human-readable outcome message regarding the outcome of
+  // the last death test.
+  static const char* LastMessage();
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN(DeathTest);
+};
+
+// Factory interface for death tests.  May be mocked out for testing.
+class DeathTestFactory {
+ public:
+  virtual ~DeathTestFactory() { }
+  virtual bool Create(const char* statement, const RE* regex,
+                      const char* file, int line, DeathTest** test) = 0;
+};
+
+// A concrete DeathTestFactory implementation for normal use.
+class DefaultDeathTestFactory : public DeathTestFactory {
+ public:
+  virtual bool Create(const char* statement, const RE* regex,
+                      const char* file, int line, DeathTest** test);
+};
+
+// Returns true if exit_status describes a process that was terminated
+// by a signal, or exited normally with a nonzero exit code.
+bool ExitedUnsuccessfully(int exit_status);
+
+// This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*,
+// ASSERT_EXIT*, and EXPECT_EXIT*.
+#define GTEST_DEATH_TEST(statement, predicate, regex, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER \
+  if (true) { \
+    const ::testing::internal::RE& gtest_regex = (regex); \
+    ::testing::internal::DeathTest* gtest_dt; \
+    if (!::testing::internal::DeathTest::Create(#statement, &gtest_regex, \
+        __FILE__, __LINE__, &gtest_dt)) { \
+      goto GTEST_CONCAT_TOKEN(gtest_label_, __LINE__); \
+    } \
+    if (gtest_dt != NULL) { \
+      ::testing::internal::scoped_ptr< ::testing::internal::DeathTest> \
+          gtest_dt_ptr(gtest_dt); \
+      switch (gtest_dt->AssumeRole()) { \
+        case ::testing::internal::DeathTest::OVERSEE_TEST: \
+          if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) { \
+            goto GTEST_CONCAT_TOKEN(gtest_label_, __LINE__); \
+          } \
+          break; \
+        case ::testing::internal::DeathTest::EXECUTE_TEST: { \
+          ::testing::internal::DeathTest::ReturnSentinel \
+              gtest_sentinel(gtest_dt); \
+          { statement; } \
+          gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE); \
+          break; \
+        } \
+      } \
+    } \
+  } else \
+    GTEST_CONCAT_TOKEN(gtest_label_, __LINE__): \
+      fail(::testing::internal::DeathTest::LastMessage())
+// The symbol "fail" here expands to something into which a message
+// can be streamed.
+
+// A struct representing the parsed contents of the
+// --gtest_internal_run_death_test flag, as it existed when
+// RUN_ALL_TESTS was called.
+struct InternalRunDeathTestFlag {
+  String file;
+  int line;
+  int index;
+  int status_fd;
+};
+
+// Returns a newly created InternalRunDeathTestFlag object with fields
+// initialized from the GTEST_FLAG(internal_run_death_test) flag if
+// the flag is specified; otherwise returns NULL.
+InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag();
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/internal/gtest-filepath.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/internal/gtest-filepath.h
new file mode 100644
index 0000000..308a2c6
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/internal/gtest-filepath.h
@@ -0,0 +1,156 @@
+// 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.
+//
+// Author: keith.ray@gmail.com (Keith Ray)
+//
+// Google Test filepath utilities
+//
+// This header file declares classes and functions used internally by
+// Google Test.  They are subject to change without notice.
+//
+// This file is #included in testing/base/internal/gtest-internal.h
+// Do not include this header file separately!
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
+
+#include <gtest/internal/gtest-string.h>
+
+namespace testing {
+namespace internal {
+
+// FilePath - a class for file and directory pathname manipulation which
+// handles platform-specific conventions (like the pathname separator).
+// Used for helper functions for naming files in a directory for xml output.
+// Except for Set methods, all methods are const or static, which provides an
+// "immutable value object" -- useful for peace of mind.
+// A FilePath with a value ending in a path separator ("like/this/") represents
+// a directory, otherwise it is assumed to represent a file. In either case,
+// it may or may not represent an actual file or directory in the file system.
+// Names are NOT checked for syntax correctness -- no checking for illegal
+// characters, malformed paths, etc.
+
+class FilePath {
+ public:
+  FilePath() : pathname_("") { }
+  FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
+  explicit FilePath(const char* pathname) : pathname_(pathname) { }
+  explicit FilePath(const String& pathname) : pathname_(pathname) { }
+
+  void Set(const FilePath& rhs) {
+    pathname_ = rhs.pathname_;
+  }
+
+  String ToString() const { return pathname_; }
+  const char* c_str() const { return pathname_.c_str(); }
+
+  // Given directory = "dir", base_name = "test", number = 0,
+  // extension = "xml", returns "dir/test.xml". If number is greater
+  // than zero (e.g., 12), returns "dir/test_12.xml".
+  // On Windows platform, uses \ as the separator rather than /.
+  static FilePath MakeFileName(const FilePath& directory,
+                               const FilePath& base_name,
+                               int number,
+                               const char* extension);
+
+  // Returns a pathname for a file that does not currently exist. The pathname
+  // will be directory/base_name.extension or
+  // directory/base_name_<number>.extension if directory/base_name.extension
+  // already exists. The number will be incremented until a pathname is found
+  // that does not already exist.
+  // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
+  // There could be a race condition if two or more processes are calling this
+  // function at the same time -- they could both pick the same filename.
+  static FilePath GenerateUniqueFileName(const FilePath& directory,
+                                         const FilePath& base_name,
+                                         const char* extension);
+
+  // If input name has a trailing separator character, removes it and returns
+  // the name, otherwise return the name string unmodified.
+  // On Windows platform, uses \ as the separator, other platforms use /.
+  FilePath RemoveTrailingPathSeparator() const;
+
+  // Returns a copy of the FilePath with the directory part removed.
+  // Example: FilePath("path/to/file").RemoveDirectoryName() returns
+  // FilePath("file"). If there is no directory part ("just_a_file"), it returns
+  // the FilePath unmodified. If there is no file part ("just_a_dir/") it
+  // returns an empty FilePath ("").
+  // On Windows platform, '\' is the path separator, otherwise it is '/'.
+  FilePath RemoveDirectoryName() const;
+
+  // RemoveFileName returns the directory path with the filename removed.
+  // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
+  // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
+  // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
+  // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
+  // On Windows platform, '\' is the path separator, otherwise it is '/'.
+  FilePath RemoveFileName() const;
+
+  // Returns a copy of the FilePath with the case-insensitive extension removed.
+  // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
+  // FilePath("dir/file"). If a case-insensitive extension is not
+  // found, returns a copy of the original FilePath.
+  FilePath RemoveExtension(const char* extension) const;
+
+  // Creates directories so that path exists. Returns true if successful or if
+  // the directories already exist; returns false if unable to create
+  // directories for any reason. Will also return false if the FilePath does
+  // not represent a directory (that is, it doesn't end with a path separator).
+  bool CreateDirectoriesRecursively() const;
+
+  // Create the directory so that path exists. Returns true if successful or
+  // if the directory already exists; returns false if unable to create the
+  // directory for any reason, including if the parent directory does not
+  // exist. Not named "CreateDirectory" because that's a macro on Windows.
+  bool CreateFolder() const;
+
+  // Returns true if FilePath describes something in the file-system,
+  // either a file, directory, or whatever, and that something exists.
+  bool FileOrDirectoryExists() const;
+
+  // Returns true if pathname describes a directory in the file-system
+  // that exists.
+  bool DirectoryExists() const;
+
+  // Returns true if FilePath ends with a path separator, which indicates that
+  // it is intended to represent a directory. Returns false otherwise.
+  // This does NOT check that a directory (or file) actually exists.
+  bool IsDirectory() const;
+
+ private:
+  String pathname_;
+
+  // Don't implement operator= because it is banned by the style guide.
+  FilePath& operator=(const FilePath& rhs);
+};  // class FilePath
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/internal/gtest-internal.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/internal/gtest-internal.h
new file mode 100644
index 0000000..2eefc7b
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/internal/gtest-internal.h
@@ -0,0 +1,546 @@
+// Copyright 2005, 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.
+//
+// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file declares functions and macros used internally by
+// Google Test.  They are subject to change without notice.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
+
+#include <gtest/internal/gtest-port.h>
+
+#ifdef GTEST_OS_LINUX
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#endif  // GTEST_OS_LINUX
+
+#include <iomanip>  // NOLINT
+#include <limits>   // NOLINT
+
+#include <gtest/internal/gtest-string.h>
+#include <gtest/internal/gtest-filepath.h>
+
+// Due to C++ preprocessor weirdness, we need double indirection to
+// concatenate two tokens when one of them is __LINE__.  Writing
+//
+//   foo ## __LINE__
+//
+// will result in the token foo__LINE__, instead of foo followed by
+// the current line number.  For more details, see
+// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
+#define GTEST_CONCAT_TOKEN(foo, bar) GTEST_CONCAT_TOKEN_IMPL(foo, bar)
+#define GTEST_CONCAT_TOKEN_IMPL(foo, bar) foo ## bar
+
+// Google Test defines the testing::Message class to allow construction of
+// test messages via the << operator.  The idea is that anything
+// streamable to std::ostream can be streamed to a testing::Message.
+// This allows a user to use his own types in Google Test assertions by
+// overloading the << operator.
+//
+// util/gtl/stl_logging-inl.h overloads << for STL containers.  These
+// overloads cannot be defined in the std namespace, as that will be
+// undefined behavior.  Therefore, they are defined in the global
+// namespace instead.
+//
+// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
+// overloads are visible in either the std namespace or the global
+// namespace, but not other namespaces, including the testing
+// namespace which Google Test's Message class is in.
+//
+// To allow STL containers (and other types that has a << operator
+// defined in the global namespace) to be used in Google Test assertions,
+// testing::Message must access the custom << operator from the global
+// namespace.  Hence this helper function.
+//
+// Note: Jeffrey Yasskin suggested an alternative fix by "using
+// ::operator<<;" in the definition of Message's operator<<.  That fix
+// doesn't require a helper function, but unfortunately doesn't
+// compile with MSVC.
+template <typename T>
+inline void GTestStreamToHelper(std::ostream* os, const T& val) {
+  *os << val;
+}
+
+namespace testing {
+
+// Forward declaration of classes.
+
+class Message;                         // Represents a failure message.
+class TestCase;                        // A collection of related tests.
+class TestPartResult;                  // Result of a test part.
+class TestInfo;                        // Information about a test.
+class UnitTest;                        // A collection of test cases.
+class UnitTestEventListenerInterface;  // Listens to Google Test events.
+class AssertionResult;                 // Result of an assertion.
+
+namespace internal {
+
+struct TraceInfo;                      // Information about a trace point.
+class ScopedTrace;                     // Implements scoped trace.
+class TestInfoImpl;                    // Opaque implementation of TestInfo
+class TestResult;                      // Result of a single Test.
+class UnitTestImpl;                    // Opaque implementation of UnitTest
+
+template <typename E> class List;      // A generic list.
+template <typename E> class ListNode;  // A node in a generic list.
+
+// A secret type that Google Test users don't know about.  It has no
+// definition on purpose.  Therefore it's impossible to create a
+// Secret object, which is what we want.
+class Secret;
+
+// Two overloaded helpers for checking at compile time whether an
+// expression is a null pointer literal (i.e. NULL or any 0-valued
+// compile-time integral constant).  Their return values have
+// different sizes, so we can use sizeof() to test which version is
+// picked by the compiler.  These helpers have no implementations, as
+// we only need their signatures.
+//
+// Given IsNullLiteralHelper(x), the compiler will pick the first
+// version if x can be implicitly converted to Secret*, and pick the
+// second version otherwise.  Since Secret is a secret and incomplete
+// type, the only expression a user can write that has type Secret* is
+// a null pointer literal.  Therefore, we know that x is a null
+// pointer literal if and only if the first version is picked by the
+// compiler.
+char IsNullLiteralHelper(Secret* p);
+char (&IsNullLiteralHelper(...))[2];  // NOLINT
+
+// A compile-time bool constant that is true if and only if x is a
+// null pointer literal (i.e. NULL or any 0-valued compile-time
+// integral constant).
+#ifdef __SYMBIAN32__  // Symbian
+// Passing non-POD classes through ellipsis (...) crashes the ARM compiler.
+// The Nokia Symbian compiler tries to instantiate a copy constructor for
+// objects passed through ellipsis (...), failing for uncopyable objects.
+// Hence we define this to false (and lose support for NULL detection).
+#define GTEST_IS_NULL_LITERAL(x) false
+#else  // ! __SYMBIAN32__
+#define GTEST_IS_NULL_LITERAL(x) \
+    (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1)
+#endif  // __SYMBIAN32__
+
+// Appends the user-supplied message to the Google-Test-generated message.
+String AppendUserMessage(const String& gtest_msg,
+                         const Message& user_msg);
+
+// A helper class for creating scoped traces in user programs.
+class ScopedTrace {
+ public:
+  // The c'tor pushes the given source file location and message onto
+  // a trace stack maintained by Google Test.
+  ScopedTrace(const char* file, int line, const Message& message);
+
+  // The d'tor pops the info pushed by the c'tor.
+  //
+  // Note that the d'tor is not virtual in order to be efficient.
+  // Don't inherit from ScopedTrace!
+  ~ScopedTrace();
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN(ScopedTrace);
+} GTEST_ATTRIBUTE_UNUSED;  // A ScopedTrace object does its job in its
+                           // c'tor and d'tor.  Therefore it doesn't
+                           // need to be used otherwise.
+
+// Converts a streamable value to a String.  A NULL pointer is
+// converted to "(null)".  When the input value is a ::string,
+// ::std::string, ::wstring, or ::std::wstring object, each NUL
+// character in it is replaced with "\\0".
+// Declared here but defined in gtest.h, so that it has access
+// to the definition of the Message class, required by the ARM
+// compiler.
+template <typename T>
+String StreamableToString(const T& streamable);
+
+// Formats a value to be used in a failure message.
+
+#ifdef __SYMBIAN32__
+
+// These are needed as the Nokia Symbian Compiler cannot decide between
+// const T& and const T* in a function template. The Nokia compiler _can_
+// decide between class template specializations for T and T*, so a
+// tr1::type_traits-like is_pointer works, and we can overload on that.
+
+// This overload makes sure that all pointers (including
+// those to char or wchar_t) are printed as raw pointers.
+template <typename T>
+inline String FormatValueForFailureMessage(internal::true_type dummy,
+                                           T* pointer) {
+  return StreamableToString(static_cast<const void*>(pointer));
+}
+
+template <typename T>
+inline String FormatValueForFailureMessage(internal::false_type dummy,
+                                           const T& value) {
+  return StreamableToString(value);
+}
+
+template <typename T>
+inline String FormatForFailureMessage(const T& value) {
+  return FormatValueForFailureMessage(
+      typename internal::is_pointer<T>::type(), value);
+}
+
+#else
+
+template <typename T>
+inline String FormatForFailureMessage(const T& value) {
+  return StreamableToString(value);
+}
+
+// This overload makes sure that all pointers (including
+// those to char or wchar_t) are printed as raw pointers.
+template <typename T>
+inline String FormatForFailureMessage(T* pointer) {
+  return StreamableToString(static_cast<const void*>(pointer));
+}
+
+#endif  // __SYMBIAN32__
+
+// These overloaded versions handle narrow and wide characters.
+String FormatForFailureMessage(char ch);
+String FormatForFailureMessage(wchar_t wchar);
+
+// When this operand is a const char* or char*, and the other operand
+// is a ::std::string or ::string, we print this operand as a C string
+// rather than a pointer.  We do the same for wide strings.
+
+// This internal macro is used to avoid duplicated code.
+#define GTEST_FORMAT_IMPL(operand2_type, operand1_printer)\
+inline String FormatForComparisonFailureMessage(\
+    operand2_type::value_type* str, const operand2_type& /*operand2*/) {\
+  return operand1_printer(str);\
+}\
+inline String FormatForComparisonFailureMessage(\
+    const operand2_type::value_type* str, const operand2_type& /*operand2*/) {\
+  return operand1_printer(str);\
+}
+
+#if GTEST_HAS_STD_STRING
+GTEST_FORMAT_IMPL(::std::string, String::ShowCStringQuoted)
+#endif  // GTEST_HAS_STD_STRING
+#if GTEST_HAS_STD_WSTRING
+GTEST_FORMAT_IMPL(::std::wstring, String::ShowWideCStringQuoted)
+#endif  // GTEST_HAS_STD_WSTRING
+
+#if GTEST_HAS_GLOBAL_STRING
+GTEST_FORMAT_IMPL(::string, String::ShowCStringQuoted)
+#endif  // GTEST_HAS_GLOBAL_STRING
+#if GTEST_HAS_GLOBAL_WSTRING
+GTEST_FORMAT_IMPL(::wstring, String::ShowWideCStringQuoted)
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+#undef GTEST_FORMAT_IMPL
+
+// Constructs and returns the message for an equality assertion
+// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
+//
+// The first four parameters are the expressions used in the assertion
+// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
+// where foo is 5 and bar is 6, we have:
+//
+//   expected_expression: "foo"
+//   actual_expression:   "bar"
+//   expected_value:      "5"
+//   actual_value:        "6"
+//
+// The ignoring_case parameter is true iff the assertion is a
+// *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will
+// be inserted into the message.
+AssertionResult EqFailure(const char* expected_expression,
+                          const char* actual_expression,
+                          const String& expected_value,
+                          const String& actual_value,
+                          bool ignoring_case);
+
+
+// This template class represents an IEEE floating-point number
+// (either single-precision or double-precision, depending on the
+// template parameters).
+//
+// The purpose of this class is to do more sophisticated number
+// comparison.  (Due to round-off error, etc, it's very unlikely that
+// two floating-points will be equal exactly.  Hence a naive
+// comparison by the == operation often doesn't work.)
+//
+// Format of IEEE floating-point:
+//
+//   The most-significant bit being the leftmost, an IEEE
+//   floating-point looks like
+//
+//     sign_bit exponent_bits fraction_bits
+//
+//   Here, sign_bit is a single bit that designates the sign of the
+//   number.
+//
+//   For float, there are 8 exponent bits and 23 fraction bits.
+//
+//   For double, there are 11 exponent bits and 52 fraction bits.
+//
+//   More details can be found at
+//   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
+//
+// Template parameter:
+//
+//   RawType: the raw floating-point type (either float or double)
+template <typename RawType>
+class FloatingPoint {
+ public:
+  // Defines the unsigned integer type that has the same size as the
+  // floating point number.
+  typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;
+
+  // Constants.
+
+  // # of bits in a number.
+  static const size_t kBitCount = 8*sizeof(RawType);
+
+  // # of fraction bits in a number.
+  static const size_t kFractionBitCount =
+    std::numeric_limits<RawType>::digits - 1;
+
+  // # of exponent bits in a number.
+  static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;
+
+  // The mask for the sign bit.
+  static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);
+
+  // The mask for the fraction bits.
+  static const Bits kFractionBitMask =
+    ~static_cast<Bits>(0) >> (kExponentBitCount + 1);
+
+  // The mask for the exponent bits.
+  static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);
+
+  // How many ULP's (Units in the Last Place) we want to tolerate when
+  // comparing two numbers.  The larger the value, the more error we
+  // allow.  A 0 value means that two numbers must be exactly the same
+  // to be considered equal.
+  //
+  // The maximum error of a single floating-point operation is 0.5
+  // units in the last place.  On Intel CPU's, all floating-point
+  // calculations are done with 80-bit precision, while double has 64
+  // bits.  Therefore, 4 should be enough for ordinary use.
+  //
+  // See the following article for more details on ULP:
+  // http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm.
+  static const size_t kMaxUlps = 4;
+
+  // Constructs a FloatingPoint from a raw floating-point number.
+  //
+  // On an Intel CPU, passing a non-normalized NAN (Not a Number)
+  // around may change its bits, although the new value is guaranteed
+  // to be also a NAN.  Therefore, don't expect this constructor to
+  // preserve the bits in x when x is a NAN.
+  explicit FloatingPoint(const RawType& x) : value_(x) {}
+
+  // Static methods
+
+  // Reinterprets a bit pattern as a floating-point number.
+  //
+  // This function is needed to test the AlmostEquals() method.
+  static RawType ReinterpretBits(const Bits bits) {
+    FloatingPoint fp(0);
+    fp.bits_ = bits;
+    return fp.value_;
+  }
+
+  // Returns the floating-point number that represent positive infinity.
+  static RawType Infinity() {
+    return ReinterpretBits(kExponentBitMask);
+  }
+
+  // Non-static methods
+
+  // Returns the bits that represents this number.
+  const Bits &bits() const { return bits_; }
+
+  // Returns the exponent bits of this number.
+  Bits exponent_bits() const { return kExponentBitMask & bits_; }
+
+  // Returns the fraction bits of this number.
+  Bits fraction_bits() const { return kFractionBitMask & bits_; }
+
+  // Returns the sign bit of this number.
+  Bits sign_bit() const { return kSignBitMask & bits_; }
+
+  // Returns true iff this is NAN (not a number).
+  bool is_nan() const {
+    // It's a NAN if the exponent bits are all ones and the fraction
+    // bits are not entirely zeros.
+    return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
+  }
+
+  // Returns true iff this number is at most kMaxUlps ULP's away from
+  // rhs.  In particular, this function:
+  //
+  //   - returns false if either number is (or both are) NAN.
+  //   - treats really large numbers as almost equal to infinity.
+  //   - thinks +0.0 and -0.0 are 0 DLP's apart.
+  bool AlmostEquals(const FloatingPoint& rhs) const {
+    // The IEEE standard says that any comparison operation involving
+    // a NAN must return false.
+    if (is_nan() || rhs.is_nan()) return false;
+
+    return DistanceBetweenSignAndMagnitudeNumbers(bits_, rhs.bits_) <= kMaxUlps;
+  }
+
+ private:
+  // Converts an integer from the sign-and-magnitude representation to
+  // the biased representation.  More precisely, let N be 2 to the
+  // power of (kBitCount - 1), an integer x is represented by the
+  // unsigned number x + N.
+  //
+  // For instance,
+  //
+  //   -N + 1 (the most negative number representable using
+  //          sign-and-magnitude) is represented by 1;
+  //   0      is represented by N; and
+  //   N - 1  (the biggest number representable using
+  //          sign-and-magnitude) is represented by 2N - 1.
+  //
+  // Read http://en.wikipedia.org/wiki/Signed_number_representations
+  // for more details on signed number representations.
+  static Bits SignAndMagnitudeToBiased(const Bits &sam) {
+    if (kSignBitMask & sam) {
+      // sam represents a negative number.
+      return ~sam + 1;
+    } else {
+      // sam represents a positive number.
+      return kSignBitMask | sam;
+    }
+  }
+
+  // Given two numbers in the sign-and-magnitude representation,
+  // returns the distance between them as an unsigned number.
+  static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,
+                                                     const Bits &sam2) {
+    const Bits biased1 = SignAndMagnitudeToBiased(sam1);
+    const Bits biased2 = SignAndMagnitudeToBiased(sam2);
+    return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
+  }
+
+  union {
+    RawType value_;  // The raw floating-point number.
+    Bits bits_;      // The bits that represent the number.
+  };
+};
+
+// Typedefs the instances of the FloatingPoint template class that we
+// care to use.
+typedef FloatingPoint<float> Float;
+typedef FloatingPoint<double> Double;
+
+// In order to catch the mistake of putting tests that use different
+// test fixture classes in the same test case, we need to assign
+// unique IDs to fixture classes and compare them.  The TypeId type is
+// used to hold such IDs.  The user should treat TypeId as an opaque
+// type: the only operation allowed on TypeId values is to compare
+// them for equality using the == operator.
+typedef void* TypeId;
+
+// GetTypeId<T>() returns the ID of type T.  Different values will be
+// returned for different types.  Calling the function twice with the
+// same type argument is guaranteed to return the same ID.
+template <typename T>
+inline TypeId GetTypeId() {
+  static bool dummy = false;
+  // The compiler is required to create an instance of the static
+  // variable dummy for each T used to instantiate the template.
+  // Therefore, the address of dummy is guaranteed to be unique.
+  return &dummy;
+}
+
+#ifdef GTEST_OS_WINDOWS
+
+// Predicate-formatters for implementing the HRESULT checking macros
+// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}
+// We pass a long instead of HRESULT to avoid causing an
+// include dependency for the HRESULT type.
+AssertionResult IsHRESULTSuccess(const char* expr, long hr);  // NOLINT
+AssertionResult IsHRESULTFailure(const char* expr, long hr);  // NOLINT
+
+#endif  // GTEST_OS_WINDOWS
+
+}  // namespace internal
+}  // namespace testing
+
+#define GTEST_MESSAGE(message, result_type) \
+  ::testing::internal::AssertHelper(result_type, __FILE__, __LINE__, message) \
+    = ::testing::Message()
+
+#define GTEST_FATAL_FAILURE(message) \
+  return GTEST_MESSAGE(message, ::testing::TPRT_FATAL_FAILURE)
+
+#define GTEST_NONFATAL_FAILURE(message) \
+  GTEST_MESSAGE(message, ::testing::TPRT_NONFATAL_FAILURE)
+
+#define GTEST_SUCCESS(message) \
+  GTEST_MESSAGE(message, ::testing::TPRT_SUCCESS)
+
+#define GTEST_TEST_BOOLEAN(boolexpr, booltext, actual, expected, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER \
+  if (boolexpr) \
+    ; \
+  else \
+    fail("Value of: " booltext "\n  Actual: " #actual "\nExpected: " #expected)
+
+// Helper macro for defining tests.
+#define GTEST_TEST(test_case_name, test_name, parent_class)\
+class test_case_name##_##test_name##_Test : public parent_class {\
+ public:\
+  test_case_name##_##test_name##_Test() {}\
+  static ::testing::Test* NewTest() {\
+    return new test_case_name##_##test_name##_Test;\
+  }\
+ private:\
+  virtual void TestBody();\
+  static ::testing::TestInfo* const test_info_;\
+  GTEST_DISALLOW_COPY_AND_ASSIGN(test_case_name##_##test_name##_Test);\
+};\
+\
+::testing::TestInfo* const test_case_name##_##test_name##_Test::test_info_ =\
+  ::testing::TestInfo::MakeAndRegisterInstance(\
+    #test_case_name, \
+    #test_name, \
+    ::testing::internal::GetTypeId< parent_class >(), \
+    parent_class::SetUpTestCase, \
+    parent_class::TearDownTestCase, \
+    test_case_name##_##test_name##_Test::NewTest);\
+void test_case_name##_##test_name##_Test::TestBody()
+
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/internal/gtest-port.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/internal/gtest-port.h
new file mode 100644
index 0000000..0c422cd
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/internal/gtest-port.h
@@ -0,0 +1,620 @@
+// Copyright 2005, 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.
+//
+// Authors: wan@google.com (Zhanyong Wan)
+//
+// Low-level types and utilities for porting Google Test to various
+// platforms.  They are subject to change without notice.  DO NOT USE
+// THEM IN USER CODE.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
+
+// The user can define the following macros in the build script to
+// control Google Test's behavior:
+//
+//   GTEST_HAS_STD_STRING     - Define it to 1/0 to indicate that
+//                              std::string does/doesn't work (Google Test can
+//                              be used where std::string is unavailable).
+//                              Leave it undefined to let Google Test define it.
+//   GTEST_HAS_GLOBAL_STRING  - Define it to 1/0 to indicate that ::string
+//                              is/isn't available (some systems define
+//                              ::string, which is different to std::string).
+//                              Leave it undefined to let Google Test define it.
+//   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
+//                              std::wstring does/doesn't work (Google Test can
+//                              be used where std::wstring is unavailable).
+//                              Leave it undefined to let Google Test define it.
+//   GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string
+//                              is/isn't available (some systems define
+//                              ::wstring, which is different to std::wstring).
+//                              Leave it undefined to let Google Test define it.
+
+// This header defines the following utilities:
+//
+// Macros indicating the name of the Google C++ Testing Framework project:
+//   GTEST_NAME              - a string literal of the project name.
+//   GTEST_FLAG_PREFIX       - a string literal of the prefix all Google
+//                             Test flag names share.
+//   GTEST_FLAG_PREFIX_UPPER - a string literal of the prefix all Google
+//                             Test flag names share, in upper case.
+//
+// Macros indicating the current platform:
+//   GTEST_OS_CYGWIN   - defined iff compiled on Cygwin.
+//   GTEST_OS_LINUX    - defined iff compiled on Linux.
+//   GTEST_OS_MAC      - defined iff compiled on Mac OS X.
+//   GTEST_OS_WINDOWS  - defined iff compiled on Windows.
+// Note that it is possible that none of the GTEST_OS_ macros are defined.
+//
+// Macros indicating available Google Test features:
+//   GTEST_HAS_DEATH_TEST  - defined iff death tests are supported.
+//
+// Macros for basic C++ coding:
+//   GTEST_AMBIGUOUS_ELSE_BLOCKER - for disabling a gcc warning.
+//   GTEST_ATTRIBUTE_UNUSED  - declares that a class' instances don't have to
+//                             be used.
+//   GTEST_DISALLOW_COPY_AND_ASSIGN()  - disables copy ctor and operator=.
+//   GTEST_MUST_USE_RESULT   - declares that a function's result must be used.
+//
+// Synchronization:
+//   Mutex, MutexLock, ThreadLocal, GetThreadCount()
+//                  - synchronization primitives.
+//
+// Template meta programming:
+//   is_pointer     - as in TR1; needed on Symbian only.
+//
+// Smart pointers:
+//   scoped_ptr     - as in TR2.
+//
+// Regular expressions:
+//   RE             - a simple regular expression class using the POSIX
+//                    Extended Regular Expression syntax.  Not available on
+//                    Windows.
+//
+// Logging:
+//   GTEST_LOG()    - logs messages at the specified severity level.
+//   LogToStderr()  - directs all log messages to stderr.
+//   FlushInfoLog() - flushes informational log messages.
+//
+// Stderr capturing:
+//   CaptureStderr()     - starts capturing stderr.
+//   GetCapturedStderr() - stops capturing stderr and returns the captured
+//                         string.
+//
+// Integer types:
+//   TypeWithSize   - maps an integer to a int type.
+//   Int32, UInt32, Int64, UInt64, TimeInMillis
+//                  - integers of known sizes.
+//   BiggestInt     - the biggest signed integer type.
+//
+// Command-line utilities:
+//   GTEST_FLAG()       - references a flag.
+//   GTEST_DECLARE_*()  - declares a flag.
+//   GTEST_DEFINE_*()   - defines a flag.
+//   GetArgvs()         - returns the command line as a vector of strings.
+//
+// Environment variable utilities:
+//   GetEnv()             - gets the value of an environment variable.
+//   BoolFromGTestEnv()   - parses a bool environment variable.
+//   Int32FromGTestEnv()  - parses an Int32 environment variable.
+//   StringFromGTestEnv() - parses a string environment variable.
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#define GTEST_NAME "Google Test"
+#define GTEST_FLAG_PREFIX "gtest_"
+#define GTEST_FLAG_PREFIX_UPPER "GTEST_"
+
+// Determines the platform on which Google Test is compiled.
+#ifdef __CYGWIN__
+#define GTEST_OS_CYGWIN
+#elif defined _MSC_VER
+// TODO(kenton@google.com): GTEST_OS_WINDOWS is currently used to mean
+//   both "The OS is Windows" and "The compiler is MSVC".  These
+//   meanings really should be separated in order to better support
+//   Windows compilers other than MSVC.
+#define GTEST_OS_WINDOWS
+#elif defined __APPLE__
+#define GTEST_OS_MAC
+#elif defined __linux__
+#define GTEST_OS_LINUX
+#endif  // _MSC_VER
+
+// Determines whether ::std::string and ::string are available.
+
+#ifndef GTEST_HAS_STD_STRING
+// The user didn't tell us whether ::std::string is available, so we
+// need to figure it out.
+
+#ifdef GTEST_OS_WINDOWS
+// Assumes that exceptions are enabled by default.
+#ifndef _HAS_EXCEPTIONS
+#define _HAS_EXCEPTIONS 1
+#endif  // _HAS_EXCEPTIONS
+// GTEST_HAS_EXCEPTIONS is non-zero iff exceptions are enabled.  It is
+// always defined, while _HAS_EXCEPTIONS is defined only on Windows.
+#define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
+// On Windows, we can use ::std::string if the compiler version is VS
+// 2005 or above, or if exceptions are enabled.
+#define GTEST_HAS_STD_STRING ((_MSC_VER >= 1400) || GTEST_HAS_EXCEPTIONS)
+#else  // We are on Linux or Mac OS.
+#define GTEST_HAS_EXCEPTIONS 0
+#define GTEST_HAS_STD_STRING 1
+#endif  // GTEST_OS_WINDOWS
+
+#endif  // GTEST_HAS_STD_STRING
+
+#ifndef GTEST_HAS_GLOBAL_STRING
+// The user didn't tell us whether ::string is available, so we need
+// to figure it out.
+
+#define GTEST_HAS_GLOBAL_STRING 0
+
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+#ifndef GTEST_HAS_STD_WSTRING
+// The user didn't tell us whether ::std::wstring is available, so we need
+// to figure it out.
+// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring
+//   is available.
+
+#ifdef GTEST_OS_CYGWIN
+// At least some versions of cygwin doesn't support ::std::wstring.
+#define GTEST_HAS_STD_WSTRING 0
+#else
+#define GTEST_HAS_STD_WSTRING GTEST_HAS_STD_STRING
+#endif  // GTEST_OS_CYGWIN
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+#ifndef GTEST_HAS_GLOBAL_WSTRING
+// The user didn't tell us whether ::wstring is available, so we need
+// to figure it out.
+#define GTEST_HAS_GLOBAL_WSTRING GTEST_HAS_GLOBAL_STRING
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+#if GTEST_HAS_STD_STRING || GTEST_HAS_GLOBAL_STRING || \
+    GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
+#include <string>  // NOLINT
+#endif  // GTEST_HAS_STD_STRING || GTEST_HAS_GLOBAL_STRING ||
+        // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
+
+#if GTEST_HAS_STD_STRING
+#include <sstream>  // NOLINT
+#else
+#include <strstream>  // NOLINT
+#endif  // GTEST_HAS_STD_STRING
+
+// Determines whether to support death tests.
+#if GTEST_HAS_STD_STRING && defined(GTEST_OS_LINUX)
+#define GTEST_HAS_DEATH_TEST
+// On some platforms, <regex.h> needs someone to define size_t, and
+// won't compile otherwise.  We can #include it here as we already
+// included <stdlib.h>, which is guaranteed to define size_t through
+// <stddef.h>.
+#include <regex.h>
+#include <vector>
+#include <fcntl.h>
+#include <sys/mman.h>
+#endif  // GTEST_HAS_STD_STRING && defined(GTEST_OS_LINUX)
+
+// Defines some utility macros.
+
+// The GNU compiler emits a warning if nested "if" statements are followed by
+// an "else" statement and braces are not used to explicitly disambiguate the
+// "else" binding.  This leads to problems with code like:
+//
+//   if (gate)
+//     ASSERT_*(condition) << "Some message";
+//
+// The "switch (0) case 0:" idiom is used to suppress this.
+#ifdef __INTEL_COMPILER
+#define GTEST_AMBIGUOUS_ELSE_BLOCKER
+#else
+#define GTEST_AMBIGUOUS_ELSE_BLOCKER switch (0) case 0:  // NOLINT
+#endif
+
+// Use this annotation at the end of a struct / class definition to
+// prevent the compiler from optimizing away instances that are never
+// used.  This is useful when all interesting logic happens inside the
+// c'tor and / or d'tor.  Example:
+//
+//   struct Foo {
+//     Foo() { ... }
+//   } GTEST_ATTRIBUTE_UNUSED;
+#if defined(GTEST_OS_WINDOWS) || (defined(GTEST_OS_LINUX) && defined(SWIG))
+#define GTEST_ATTRIBUTE_UNUSED
+#else
+#define GTEST_ATTRIBUTE_UNUSED __attribute__ ((unused))
+#endif  // GTEST_OS_WINDOWS || (GTEST_OS_LINUX && SWIG)
+
+// A macro to disallow the evil copy constructor and operator= functions
+// This should be used in the private: declarations for a class.
+#define GTEST_DISALLOW_COPY_AND_ASSIGN(type)\
+  type(const type &);\
+  void operator=(const type &)
+
+// Tell the compiler to warn about unused return values for functions declared
+// with this macro.  The macro should be used on function declarations
+// following the argument list:
+//
+//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT;
+#if defined(__GNUC__) \
+  && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) \
+  && !defined(COMPILER_ICC)
+#define GTEST_MUST_USE_RESULT __attribute__ ((warn_unused_result))
+#else
+#define GTEST_MUST_USE_RESULT
+#endif  // (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+
+namespace testing {
+
+class Message;
+
+namespace internal {
+
+class String;
+
+// std::strstream is deprecated.  However, we have to use it on
+// Windows as std::stringstream won't compile on Windows when
+// exceptions are disabled.  We use std::stringstream on other
+// platforms to avoid compiler warnings there.
+#if GTEST_HAS_STD_STRING
+typedef ::std::stringstream StrStream;
+#else
+typedef ::std::strstream StrStream;
+#endif  // GTEST_HAS_STD_STRING
+
+// Defines scoped_ptr.
+
+// This implementation of scoped_ptr is PARTIAL - it only contains
+// enough stuff to satisfy Google Test's need.
+template <typename T>
+class scoped_ptr {
+ public:
+  explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
+  ~scoped_ptr() { reset(); }
+
+  T& operator*() const { return *ptr_; }
+  T* operator->() const { return ptr_; }
+  T* get() const { return ptr_; }
+
+  T* release() {
+    T* const ptr = ptr_;
+    ptr_ = NULL;
+    return ptr;
+  }
+
+  void reset(T* p = NULL) {
+    if (p != ptr_) {
+      if (sizeof(T) > 0) {  // Makes sure T is a complete type.
+        delete ptr_;
+      }
+      ptr_ = p;
+    }
+  }
+ private:
+  T* ptr_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN(scoped_ptr);
+};
+
+#ifdef GTEST_HAS_DEATH_TEST
+
+// Defines RE.  Currently only needed for death tests.
+
+// A simple C++ wrapper for <regex.h>.  It uses the POSIX Enxtended
+// Regular Expression syntax.
+class RE {
+ public:
+  // Constructs an RE from a string.
+#if GTEST_HAS_STD_STRING
+  RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT
+#endif  // GTEST_HAS_STD_STRING
+
+#if GTEST_HAS_GLOBAL_STRING
+  RE(const ::string& regex) { Init(regex.c_str()); }  // NOLINT
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+  RE(const char* regex) { Init(regex); }  // NOLINT
+  ~RE();
+
+  // Returns the string representation of the regex.
+  const char* pattern() const { return pattern_; }
+
+  // Returns true iff str contains regular expression re.
+
+  // TODO(wan): make PartialMatch() work when str contains NUL
+  // characters.
+#if GTEST_HAS_STD_STRING
+  static bool PartialMatch(const ::std::string& str, const RE& re) {
+    return PartialMatch(str.c_str(), re);
+  }
+#endif  // GTEST_HAS_STD_STRING
+
+#if GTEST_HAS_GLOBAL_STRING
+  static bool PartialMatch(const ::string& str, const RE& re) {
+    return PartialMatch(str.c_str(), re);
+  }
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+  static bool PartialMatch(const char* str, const RE& re);
+
+ private:
+  void Init(const char* regex);
+
+  // We use a const char* instead of a string, as Google Test may be used
+  // where string is not available.  We also do not use Google Test's own
+  // String type here, in order to simplify dependencies between the
+  // files.
+  const char* pattern_;
+  regex_t regex_;
+  bool is_valid_;
+};
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Defines logging utilities:
+//   GTEST_LOG()    - logs messages at the specified severity level.
+//   LogToStderr()  - directs all log messages to stderr.
+//   FlushInfoLog() - flushes informational log messages.
+
+enum GTestLogSeverity {
+  GTEST_INFO,
+  GTEST_WARNING,
+  GTEST_ERROR,
+  GTEST_FATAL
+};
+
+void GTestLog(GTestLogSeverity severity, const char* file,
+              int line, const char* msg);
+
+#define GTEST_LOG(severity, msg)\
+    ::testing::internal::GTestLog(\
+        ::testing::internal::GTEST_##severity, __FILE__, __LINE__, \
+        (::testing::Message() << (msg)).GetString().c_str())
+
+inline void LogToStderr() {}
+inline void FlushInfoLog() { fflush(NULL); }
+
+// Defines the stderr capturer:
+//   CaptureStderr     - starts capturing stderr.
+//   GetCapturedStderr - stops capturing stderr and returns the captured string.
+
+#ifdef GTEST_HAS_DEATH_TEST
+
+// A copy of all command line arguments.  Set by InitGoogleTest().
+extern ::std::vector<String> g_argvs;
+
+void CaptureStderr();
+// GTEST_HAS_DEATH_TEST implies we have ::std::string.
+::std::string GetCapturedStderr();
+const ::std::vector<String>& GetArgvs();
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Defines synchronization primitives.
+
+// A dummy implementation of synchronization primitives (mutex, lock,
+// and thread-local variable).  Necessary for compiling Google Test where
+// mutex is not supported - using Google Test in multiple threads is not
+// supported on such platforms.
+
+class Mutex {
+ public:
+  Mutex() {}
+  explicit Mutex(int /*unused*/) {}
+  void AssertHeld() const {}
+  enum { NO_CONSTRUCTOR_NEEDED_FOR_STATIC_MUTEX = 0 };
+};
+
+// We cannot call it MutexLock directly as the ctor declaration would
+// conflict with a macro named MutexLock, which is defined on some
+// platforms.  Hence the typedef trick below.
+class GTestMutexLock {
+ public:
+  explicit GTestMutexLock(Mutex*) {}  // NOLINT
+};
+
+typedef GTestMutexLock MutexLock;
+
+template <typename T>
+class ThreadLocal {
+ public:
+  T* pointer() { return &value_; }
+  const T* pointer() const { return &value_; }
+  const T& get() const { return value_; }
+  void set(const T& value) { value_ = value; }
+ private:
+  T value_;
+};
+
+// There's no portable way to detect the number of threads, so we just
+// return 0 to indicate that we cannot detect it.
+inline size_t GetThreadCount() { return 0; }
+
+// Defines tr1::is_pointer (only needed for Symbian).
+
+#ifdef __SYMBIAN32__
+
+// Symbian does not have tr1::type_traits, so we define our own is_pointer
+// These are needed as the Nokia Symbian Compiler cannot decide between
+// const T& and const T* in a function template.
+
+template <bool bool_value>
+struct bool_constant {
+  typedef bool_constant<bool_value> type;
+  static const bool value = bool_value;
+};
+template <bool bool_value> const bool bool_constant<bool_value>::value;
+
+typedef bool_constant<false> false_type;
+typedef bool_constant<true> true_type;
+
+template <typename T>
+struct is_pointer : public false_type {};
+
+template <typename T>
+struct is_pointer<T*> : public true_type {};
+
+#endif  // __SYMBIAN32__
+
+// Defines BiggestInt as the biggest signed integer type the compiler
+// supports.
+
+#ifdef GTEST_OS_WINDOWS
+typedef __int64 BiggestInt;
+#else
+typedef long long BiggestInt;  // NOLINT
+#endif  // GTEST_OS_WINDOWS
+
+// The maximum number a BiggestInt can represent.  This definition
+// works no matter BiggestInt is represented in one's complement or
+// two's complement.
+//
+// We cannot rely on numeric_limits in STL, as __int64 and long long
+// are not part of standard C++ and numeric_limits doesn't need to be
+// defined for them.
+const BiggestInt kMaxBiggestInt =
+    ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1));
+
+// This template class serves as a compile-time function from size to
+// type.  It maps a size in bytes to a primitive type with that
+// size. e.g.
+//
+//   TypeWithSize<4>::UInt
+//
+// is typedef-ed to be unsigned int (unsigned integer made up of 4
+// bytes).
+//
+// Such functionality should belong to STL, but I cannot find it
+// there.
+//
+// Google Test uses this class in the implementation of floating-point
+// comparison.
+//
+// For now it only handles UInt (unsigned int) as that's all Google Test
+// needs.  Other types can be easily added in the future if need
+// arises.
+template <size_t size>
+class TypeWithSize {
+ public:
+  // This prevents the user from using TypeWithSize<N> with incorrect
+  // values of N.
+  typedef void UInt;
+};
+
+// The specialization for size 4.
+template <>
+class TypeWithSize<4> {
+ public:
+  // unsigned int has size 4 in both gcc and MSVC.
+  //
+  // As base/basictypes.h doesn't compile on Windows, we cannot use
+  // uint32, uint64, and etc here.
+  typedef int Int;
+  typedef unsigned int UInt;
+};
+
+// The specialization for size 8.
+template <>
+class TypeWithSize<8> {
+ public:
+#ifdef GTEST_OS_WINDOWS
+  typedef __int64 Int;
+  typedef unsigned __int64 UInt;
+#else
+  typedef long long Int;  // NOLINT
+  typedef unsigned long long UInt;  // NOLINT
+#endif  // GTEST_OS_WINDOWS
+};
+
+// Integer types of known sizes.
+typedef TypeWithSize<4>::Int Int32;
+typedef TypeWithSize<4>::UInt UInt32;
+typedef TypeWithSize<8>::Int Int64;
+typedef TypeWithSize<8>::UInt UInt64;
+typedef TypeWithSize<8>::Int TimeInMillis;  // Represents time in milliseconds.
+
+// Utilities for command line flags and environment variables.
+
+// A wrapper for getenv() that works on Linux, Windows, and Mac OS.
+inline const char* GetEnv(const char* name) {
+#ifdef _WIN32_WCE  // We are on Windows CE.
+  // CE has no environment variables.
+  return NULL;
+#elif defined(GTEST_OS_WINDOWS)  // We are on Windows proper.
+  // MSVC 8 deprecates getenv(), so we want to suppress warning 4996
+  // (deprecated function) there.
+#pragma warning(push)          // Saves the current warning state.
+#pragma warning(disable:4996)  // Temporarily disables warning 4996.
+  return getenv(name);
+#pragma warning(pop)           // Restores the warning state.
+#else  // We are on Linux or Mac OS.
+  return getenv(name);
+#endif
+}
+
+// Macro for referencing flags.
+#define GTEST_FLAG(name) FLAGS_gtest_##name
+
+// Macros for declaring flags.
+#define GTEST_DECLARE_bool(name) extern bool GTEST_FLAG(name)
+#define GTEST_DECLARE_int32(name) \
+    extern ::testing::internal::Int32 GTEST_FLAG(name)
+#define GTEST_DECLARE_string(name) \
+    extern ::testing::internal::String GTEST_FLAG(name)
+
+// Macros for defining flags.
+#define GTEST_DEFINE_bool(name, default_val, doc) \
+    bool GTEST_FLAG(name) = (default_val)
+#define GTEST_DEFINE_int32(name, default_val, doc) \
+    ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
+#define GTEST_DEFINE_string(name, default_val, doc) \
+    ::testing::internal::String GTEST_FLAG(name) = (default_val)
+
+// Parses 'str' for a 32-bit signed integer.  If successful, writes the result
+// to *value and returns true; otherwise leaves *value unchanged and returns
+// false.
+// TODO(chandlerc): Find a better way to refactor flag and environment parsing
+// out of both gtest-port.cc and gtest.cc to avoid exporting this utility
+// function.
+bool ParseInt32(const Message& src_text, const char* str, Int32* value);
+
+// Parses a bool/Int32/string from the environment variable
+// corresponding to the given Google Test flag.
+bool BoolFromGTestEnv(const char* flag, bool default_val);
+Int32 Int32FromGTestEnv(const char* flag, Int32 default_val);
+const char* StringFromGTestEnv(const char* flag, const char* default_val);
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/internal/gtest-string.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/internal/gtest-string.h
new file mode 100644
index 0000000..b5a303f
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/internal/gtest-string.h
@@ -0,0 +1,268 @@
+// Copyright 2005, 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.
+//
+// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file declares the String class and functions used internally by
+// Google Test.  They are subject to change without notice. They should not used
+// by code external to Google Test.
+//
+// This header file is #included by testing/base/internal/gtest-internal.h.
+// It should not be #included by other files.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
+
+#include <string.h>
+#include <gtest/internal/gtest-port.h>
+
+namespace testing {
+namespace internal {
+
+// String - a UTF-8 string class.
+//
+// We cannot use std::string as Microsoft's STL implementation in
+// Visual C++ 7.1 has problems when exception is disabled.  There is a
+// hack to work around this, but we've seen cases where the hack fails
+// to work.
+//
+// Also, String is different from std::string in that it can represent
+// both NULL and the empty string, while std::string cannot represent
+// NULL.
+//
+// NULL and the empty string are considered different.  NULL is less
+// than anything (including the empty string) except itself.
+//
+// This class only provides minimum functionality necessary for
+// implementing Google Test.  We do not intend to implement a full-fledged
+// string class here.
+//
+// Since the purpose of this class is to provide a substitute for
+// std::string on platforms where it cannot be used, we define a copy
+// constructor and assignment operators such that we don't need
+// conditional compilation in a lot of places.
+//
+// In order to make the representation efficient, the d'tor of String
+// is not virtual.  Therefore DO NOT INHERIT FROM String.
+class String {
+ public:
+  // Static utility methods
+
+  // Returns the input if it's not NULL, otherwise returns "(null)".
+  // This function serves two purposes:
+  //
+  // 1. ShowCString(NULL) has type 'const char *', instead of the
+  // type of NULL (which is int).
+  //
+  // 2. In MSVC, streaming a null char pointer to StrStream generates
+  // an access violation, so we need to convert NULL to "(null)"
+  // before streaming it.
+  static inline const char* ShowCString(const char* c_str) {
+    return c_str ? c_str : "(null)";
+  }
+
+  // Returns the input enclosed in double quotes if it's not NULL;
+  // otherwise returns "(null)".  For example, "\"Hello\"" is returned
+  // for input "Hello".
+  //
+  // This is useful for printing a C string in the syntax of a literal.
+  //
+  // Known issue: escape sequences are not handled yet.
+  static String ShowCStringQuoted(const char* c_str);
+
+  // Clones a 0-terminated C string, allocating memory using new.  The
+  // caller is responsible for deleting the return value using
+  // delete[].  Returns the cloned string, or NULL if the input is
+  // NULL.
+  //
+  // This is different from strdup() in string.h, which allocates
+  // memory using malloc().
+  static const char* CloneCString(const char* c_str);
+
+  // Compares two C strings.  Returns true iff they have the same content.
+  //
+  // Unlike strcmp(), this function can handle NULL argument(s).  A
+  // NULL C string is considered different to any non-NULL C string,
+  // including the empty string.
+  static bool CStringEquals(const char* lhs, const char* rhs);
+
+  // Converts a wide C string to a String using the UTF-8 encoding.
+  // NULL will be converted to "(null)".  If an error occurred during
+  // the conversion, "(failed to convert from wide string)" is
+  // returned.
+  static String ShowWideCString(const wchar_t* wide_c_str);
+
+  // Similar to ShowWideCString(), except that this function encloses
+  // the converted string in double quotes.
+  static String ShowWideCStringQuoted(const wchar_t* wide_c_str);
+
+  // Compares two wide C strings.  Returns true iff they have the same
+  // content.
+  //
+  // Unlike wcscmp(), this function can handle NULL argument(s).  A
+  // NULL C string is considered different to any non-NULL C string,
+  // including the empty string.
+  static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs);
+
+  // Compares two C strings, ignoring case.  Returns true iff they
+  // have the same content.
+  //
+  // Unlike strcasecmp(), this function can handle NULL argument(s).
+  // A NULL C string is considered different to any non-NULL C string,
+  // including the empty string.
+  static bool CaseInsensitiveCStringEquals(const char* lhs,
+                                           const char* rhs);
+
+  // Formats a list of arguments to a String, using the same format
+  // spec string as for printf.
+  //
+  // We do not use the StringPrintf class as it is not universally
+  // available.
+  //
+  // The result is limited to 4096 characters (including the tailing
+  // 0).  If 4096 characters are not enough to format the input,
+  // "<buffer exceeded>" is returned.
+  static String Format(const char* format, ...);
+
+  // C'tors
+
+  // The default c'tor constructs a NULL string.
+  String() : c_str_(NULL) {}
+
+  // Constructs a String by cloning a 0-terminated C string.
+  String(const char* c_str) : c_str_(NULL) {  // NOLINT
+    *this = c_str;
+  }
+
+  // Constructs a String by copying a given number of chars from a
+  // buffer.  E.g. String("hello", 3) will create the string "hel".
+  String(const char* buffer, size_t len);
+
+  // The copy c'tor creates a new copy of the string.  The two
+  // String objects do not share content.
+  String(const String& str) : c_str_(NULL) {
+    *this = str;
+  }
+
+  // D'tor.  String is intended to be a final class, so the d'tor
+  // doesn't need to be virtual.
+  ~String() { delete[] c_str_; }
+
+  // Returns true iff this is an empty string (i.e. "").
+  bool empty() const {
+    return (c_str_ != NULL) && (*c_str_ == '\0');
+  }
+
+  // Compares this with another String.
+  // Returns < 0 if this is less than rhs, 0 if this is equal to rhs, or > 0
+  // if this is greater than rhs.
+  int Compare(const String& rhs) const;
+
+  // Returns true iff this String equals the given C string.  A NULL
+  // string and a non-NULL string are considered not equal.
+  bool operator==(const char* c_str) const {
+    return CStringEquals(c_str_, c_str);
+  }
+
+  // Returns true iff this String doesn't equal the given C string.  A NULL
+  // string and a non-NULL string are considered not equal.
+  bool operator!=(const char* c_str) const {
+    return !CStringEquals(c_str_, c_str);
+  }
+
+  // Returns true iff this String ends with the given suffix.  *Any*
+  // String is considered to end with a NULL or empty suffix.
+  bool EndsWith(const char* suffix) const;
+
+  // Returns true iff this String ends with the given suffix, not considering
+  // case. Any String is considered to end with a NULL or empty suffix.
+  bool EndsWithCaseInsensitive(const char* suffix) const;
+
+  // Returns the length of the encapsulated string, or -1 if the
+  // string is NULL.
+  int GetLength() const {
+    return c_str_ ? static_cast<int>(strlen(c_str_)) : -1;
+  }
+
+  // Gets the 0-terminated C string this String object represents.
+  // The String object still owns the string.  Therefore the caller
+  // should NOT delete the return value.
+  const char* c_str() const { return c_str_; }
+
+  // Sets the 0-terminated C string this String object represents.
+  // The old string in this object is deleted, and this object will
+  // own a clone of the input string.  This function copies only up to
+  // length bytes (plus a terminating null byte), or until the first
+  // null byte, whichever comes first.
+  //
+  // This function works even when the c_str parameter has the same
+  // value as that of the c_str_ field.
+  void Set(const char* c_str, size_t length);
+
+  // Assigns a C string to this object.  Self-assignment works.
+  const String& operator=(const char* c_str);
+
+  // Assigns a String object to this object.  Self-assignment works.
+  const String& operator=(const String &rhs) {
+    *this = rhs.c_str_;
+    return *this;
+  }
+
+ private:
+  const char* c_str_;
+};
+
+// Streams a String to an ostream.
+inline ::std::ostream& operator <<(::std::ostream& os, const String& str) {
+  // We call String::ShowCString() to convert NULL to "(null)".
+  // Otherwise we'll get an access violation on Windows.
+  return os << String::ShowCString(str.c_str());
+}
+
+// Gets the content of the StrStream's buffer as a String.  Each '\0'
+// character in the buffer is replaced with "\\0".
+String StrStreamToString(StrStream* stream);
+
+// Converts a streamable value to a String.  A NULL pointer is
+// converted to "(null)".  When the input value is a ::string,
+// ::std::string, ::wstring, or ::std::wstring object, each NUL
+// character in it is replaced with "\\0".
+
+// Declared here but defined in gtest.h, so that it has access
+// to the definition of the Message class, required by the ARM
+// compiler.
+template <typename T>
+String StreamableToString(const T& streamable);
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/src/gtest-internal-inl.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/src/gtest-internal-inl.h
new file mode 100644
index 0000000..2a7d71c
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/gtest/src/gtest-internal-inl.h
@@ -0,0 +1,1118 @@
+// Copyright 2005, 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.
+
+// Utility functions and classes used by the Google C++ testing framework.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// This file contains purely Google Test's internal implementation.  Please
+// DO NOT #INCLUDE IT IN A USER PROGRAM.
+
+#ifndef GTEST_SRC_GTEST_INTERNAL_INL_H_
+#define GTEST_SRC_GTEST_INTERNAL_INL_H_
+
+// GTEST_IMPLEMENTATION is defined iff the current translation unit is
+// part of Google Test's implementation.
+#ifndef GTEST_IMPLEMENTATION
+// A user is trying to include this from his code - just say no.
+#error "gtest-internal-inl.h is part of Google Test's internal implementation."
+#error "It must not be included except by Google Test itself."
+#endif  // GTEST_IMPLEMENTATION
+
+#include <stddef.h>
+
+#include <gtest/internal/gtest-port.h>
+
+#ifdef GTEST_OS_WINDOWS
+#include <windows.h>  // NOLINT
+#endif  // GTEST_OS_WINDOWS
+
+#include <ostream>  // NOLINT
+#include <gtest/gtest.h>
+#include <gtest/gtest-spi.h>
+
+namespace testing {
+
+// Declares the flags.
+//
+// We don't want the users to modify these flags in the code, but want
+// Google Test's own unit tests to be able to access them.  Therefore we
+// declare them here as opposed to in gtest.h.
+GTEST_DECLARE_bool(break_on_failure);
+GTEST_DECLARE_bool(catch_exceptions);
+GTEST_DECLARE_string(color);
+GTEST_DECLARE_string(filter);
+GTEST_DECLARE_bool(list_tests);
+GTEST_DECLARE_string(output);
+GTEST_DECLARE_int32(repeat);
+GTEST_DECLARE_int32(stack_trace_depth);
+GTEST_DECLARE_bool(show_internal_stack_frames);
+
+namespace internal {
+
+// Names of the flags (needed for parsing Google Test flags).
+const char kBreakOnFailureFlag[] = "break_on_failure";
+const char kCatchExceptionsFlag[] = "catch_exceptions";
+const char kFilterFlag[] = "filter";
+const char kListTestsFlag[] = "list_tests";
+const char kOutputFlag[] = "output";
+const char kColorFlag[] = "color";
+const char kRepeatFlag[] = "repeat";
+
+// This class saves the values of all Google Test flags in its c'tor, and
+// restores them in its d'tor.
+class GTestFlagSaver {
+ public:
+  // The c'tor.
+  GTestFlagSaver() {
+    break_on_failure_ = GTEST_FLAG(break_on_failure);
+    catch_exceptions_ = GTEST_FLAG(catch_exceptions);
+    color_ = GTEST_FLAG(color);
+    death_test_style_ = GTEST_FLAG(death_test_style);
+    filter_ = GTEST_FLAG(filter);
+    internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
+    list_tests_ = GTEST_FLAG(list_tests);
+    output_ = GTEST_FLAG(output);
+    repeat_ = GTEST_FLAG(repeat);
+  }
+
+  // The d'tor is not virtual.  DO NOT INHERIT FROM THIS CLASS.
+  ~GTestFlagSaver() {
+    GTEST_FLAG(break_on_failure) = break_on_failure_;
+    GTEST_FLAG(catch_exceptions) = catch_exceptions_;
+    GTEST_FLAG(color) = color_;
+    GTEST_FLAG(death_test_style) = death_test_style_;
+    GTEST_FLAG(filter) = filter_;
+    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
+    GTEST_FLAG(list_tests) = list_tests_;
+    GTEST_FLAG(output) = output_;
+    GTEST_FLAG(repeat) = repeat_;
+  }
+ private:
+  // Fields for saving the original values of flags.
+  bool break_on_failure_;
+  bool catch_exceptions_;
+  String color_;
+  String death_test_style_;
+  String filter_;
+  String internal_run_death_test_;
+  bool list_tests_;
+  String output_;
+  bool pretty_;
+  internal::Int32 repeat_;
+} GTEST_ATTRIBUTE_UNUSED;
+
+// Converts a Unicode code-point to its UTF-8 encoding.
+String ToUtf8String(wchar_t wchar);
+
+// Returns the number of active threads, or 0 when there is an error.
+size_t GetThreadCount();
+
+// List is a simple singly-linked list container.
+//
+// We cannot use std::list as Microsoft's implementation of STL has
+// problems when exception is disabled.  There is a hack to work
+// around this, but we've seen cases where the hack fails to work.
+//
+// TODO(wan): switch to std::list when we have a reliable fix for the
+// STL problem, e.g. when we upgrade to the next version of Visual
+// C++, or (more likely) switch to STLport.
+//
+// The element type must support copy constructor.
+
+// Forward declare List
+template <typename E>  // E is the element type.
+class List;
+
+// ListNode is a node in a singly-linked list.  It consists of an
+// element and a pointer to the next node.  The last node in the list
+// has a NULL value for its next pointer.
+template <typename E>  // E is the element type.
+class ListNode {
+  friend class List<E>;
+
+ private:
+
+  E element_;
+  ListNode * next_;
+
+  // The c'tor is private s.t. only in the ListNode class and in its
+  // friend class List we can create a ListNode object.
+  //
+  // Creates a node with a given element value.  The next pointer is
+  // set to NULL.
+  //
+  // ListNode does NOT have a default constructor.  Always use this
+  // constructor (with parameter) to create a ListNode object.
+  explicit ListNode(const E & element) : element_(element), next_(NULL) {}
+
+  // We disallow copying ListNode
+  GTEST_DISALLOW_COPY_AND_ASSIGN(ListNode);
+
+ public:
+
+  // Gets the element in this node.
+  E & element() { return element_; }
+  const E & element() const { return element_; }
+
+  // Gets the next node in the list.
+  ListNode * next() { return next_; }
+  const ListNode * next() const { return next_; }
+};
+
+
+// List is a simple singly-linked list container.
+template <typename E>  // E is the element type.
+class List {
+ public:
+
+  // Creates an empty list.
+  List() : head_(NULL), last_(NULL), size_(0) {}
+
+  // D'tor.
+  virtual ~List();
+
+  // Clears the list.
+  void Clear() {
+    if ( size_ > 0 ) {
+      // 1. Deletes every node.
+      ListNode<E> * node = head_;
+      ListNode<E> * next = node->next();
+      for ( ; ; ) {
+        delete node;
+        node = next;
+        if ( node == NULL ) break;
+        next = node->next();
+      }
+
+      // 2. Resets the member variables.
+      head_ = last_ = NULL;
+      size_ = 0;
+    }
+  }
+
+  // Gets the number of elements.
+  int size() const { return size_; }
+
+  // Returns true if the list is empty.
+  bool IsEmpty() const { return size() == 0; }
+
+  // Gets the first element of the list, or NULL if the list is empty.
+  ListNode<E> * Head() { return head_; }
+  const ListNode<E> * Head() const { return head_; }
+
+  // Gets the last element of the list, or NULL if the list is empty.
+  ListNode<E> * Last() { return last_; }
+  const ListNode<E> * Last() const { return last_; }
+
+  // Adds an element to the end of the list.  A copy of the element is
+  // created using the copy constructor, and then stored in the list.
+  // Changes made to the element in the list doesn't affect the source
+  // object, and vice versa.
+  void PushBack(const E & element) {
+    ListNode<E> * new_node = new ListNode<E>(element);
+
+    if ( size_ == 0 ) {
+      head_ = last_ = new_node;
+      size_ = 1;
+    } else {
+      last_->next_ = new_node;
+      last_ = new_node;
+      size_++;
+    }
+  }
+
+  // Adds an element to the beginning of this list.
+  void PushFront(const E& element) {
+    ListNode<E>* const new_node = new ListNode<E>(element);
+
+    if ( size_ == 0 ) {
+      head_ = last_ = new_node;
+      size_ = 1;
+    } else {
+      new_node->next_ = head_;
+      head_ = new_node;
+      size_++;
+    }
+  }
+
+  // Removes an element from the beginning of this list.  If the
+  // result argument is not NULL, the removed element is stored in the
+  // memory it points to.  Otherwise the element is thrown away.
+  // Returns true iff the list wasn't empty before the operation.
+  bool PopFront(E* result) {
+    if (size_ == 0) return false;
+
+    if (result != NULL) {
+      *result = head_->element_;
+    }
+
+    ListNode<E>* const old_head = head_;
+    size_--;
+    if (size_ == 0) {
+      head_ = last_ = NULL;
+    } else {
+      head_ = head_->next_;
+    }
+    delete old_head;
+
+    return true;
+  }
+
+  // Inserts an element after a given node in the list.  It's the
+  // caller's responsibility to ensure that the given node is in the
+  // list.  If the given node is NULL, inserts the element at the
+  // front of the list.
+  ListNode<E>* InsertAfter(ListNode<E>* node, const E& element) {
+    if (node == NULL) {
+      PushFront(element);
+      return Head();
+    }
+
+    ListNode<E>* const new_node = new ListNode<E>(element);
+    new_node->next_ = node->next_;
+    node->next_ = new_node;
+    size_++;
+    if (node == last_) {
+      last_ = new_node;
+    }
+
+    return new_node;
+  }
+
+  // Returns the number of elements that satisfy a given predicate.
+  // The parameter 'predicate' is a Boolean function or functor that
+  // accepts a 'const E &', where E is the element type.
+  template <typename P>  // P is the type of the predicate function/functor
+  int CountIf(P predicate) const {
+    int count = 0;
+    for ( const ListNode<E> * node = Head();
+          node != NULL;
+          node = node->next() ) {
+      if ( predicate(node->element()) ) {
+        count++;
+      }
+    }
+
+    return count;
+  }
+
+  // Applies a function/functor to each element in the list.  The
+  // parameter 'functor' is a function/functor that accepts a 'const
+  // E &', where E is the element type.  This method does not change
+  // the elements.
+  template <typename F>  // F is the type of the function/functor
+  void ForEach(F functor) const {
+    for ( const ListNode<E> * node = Head();
+          node != NULL;
+          node = node->next() ) {
+      functor(node->element());
+    }
+  }
+
+  // Returns the first node whose element satisfies a given predicate,
+  // or NULL if none is found.  The parameter 'predicate' is a
+  // function/functor that accepts a 'const E &', where E is the
+  // element type.  This method does not change the elements.
+  template <typename P>  // P is the type of the predicate function/functor.
+  const ListNode<E> * FindIf(P predicate) const {
+    for ( const ListNode<E> * node = Head();
+          node != NULL;
+          node = node->next() ) {
+      if ( predicate(node->element()) ) {
+        return node;
+      }
+    }
+
+    return NULL;
+  }
+
+  template <typename P>
+  ListNode<E> * FindIf(P predicate) {
+    for ( ListNode<E> * node = Head();
+          node != NULL;
+          node = node->next() ) {
+      if ( predicate(node->element() ) ) {
+        return node;
+      }
+    }
+
+    return NULL;
+  }
+
+ private:
+  ListNode<E>* head_;  // The first node of the list.
+  ListNode<E>* last_;  // The last node of the list.
+  int size_;           // The number of elements in the list.
+
+  // We disallow copying List.
+  GTEST_DISALLOW_COPY_AND_ASSIGN(List);
+};
+
+// The virtual destructor of List.
+template <typename E>
+List<E>::~List() {
+  Clear();
+}
+
+// A function for deleting an object.  Handy for being used as a
+// functor.
+template <typename T>
+static void Delete(T * x) {
+  delete x;
+}
+
+// A copyable object representing a user specified test property which can be
+// output as a key/value string pair.
+//
+// Don't inherit from TestProperty as its destructor is not virtual.
+class TestProperty {
+ public:
+  // C'tor.  TestProperty does NOT have a default constructor.
+  // Always use this constructor (with parameters) to create a
+  // TestProperty object.
+  TestProperty(const char* key, const char* value) :
+    key_(key), value_(value) {
+  }
+
+  // Gets the user supplied key.
+  const char* key() const {
+    return key_.c_str();
+  }
+
+  // Gets the user supplied value.
+  const char* value() const {
+    return value_.c_str();
+  }
+
+  // Sets a new value, overriding the one supplied in the constructor.
+  void SetValue(const char* new_value) {
+    value_ = new_value;
+  }
+
+ private:
+  // The key supplied by the user.
+  String key_;
+  // The value supplied by the user.
+  String value_;
+};
+
+// A predicate that checks the key of a TestProperty against a known key.
+//
+// TestPropertyKeyIs is copyable.
+class TestPropertyKeyIs {
+ public:
+  // Constructor.
+  //
+  // TestPropertyKeyIs has NO default constructor.
+  explicit TestPropertyKeyIs(const char* key)
+      : key_(key) {}
+
+  // Returns true iff the test name of test property matches on key_.
+  bool operator()(const TestProperty& test_property) const {
+    return String(test_property.key()).Compare(key_) == 0;
+  }
+
+ private:
+  String key_;
+};
+
+// The result of a single Test.  This includes a list of
+// TestPartResults, a list of TestProperties, a count of how many
+// death tests there are in the Test, and how much time it took to run
+// the Test.
+//
+// TestResult is not copyable.
+class TestResult {
+ public:
+  // Creates an empty TestResult.
+  TestResult();
+
+  // D'tor.  Do not inherit from TestResult.
+  ~TestResult();
+
+  // Gets the list of TestPartResults.
+  const internal::List<TestPartResult> & test_part_results() const {
+    return test_part_results_;
+  }
+
+  // Gets the list of TestProperties.
+  const internal::List<internal::TestProperty> & test_properties() const {
+    return test_properties_;
+  }
+
+  // Gets the number of successful test parts.
+  int successful_part_count() const;
+
+  // Gets the number of failed test parts.
+  int failed_part_count() const;
+
+  // Gets the number of all test parts.  This is the sum of the number
+  // of successful test parts and the number of failed test parts.
+  int total_part_count() const;
+
+  // Returns true iff the test passed (i.e. no test part failed).
+  bool Passed() const { return !Failed(); }
+
+  // Returns true iff the test failed.
+  bool Failed() const { return failed_part_count() > 0; }
+
+  // Returns true iff the test fatally failed.
+  bool HasFatalFailure() const;
+
+  // Returns the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const { return elapsed_time_; }
+
+  // Sets the elapsed time.
+  void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
+
+  // Adds a test part result to the list.
+  void AddTestPartResult(const TestPartResult& test_part_result);
+
+  // Adds a test property to the list. The property is validated and may add
+  // a non-fatal failure if invalid (e.g., if it conflicts with reserved
+  // key names). If a property is already recorded for the same key, the
+  // value will be updated, rather than storing multiple values for the same
+  // key.
+  void RecordProperty(const internal::TestProperty& test_property);
+
+  // Adds a failure if the key is a reserved attribute of Google Test
+  // testcase tags.  Returns true if the property is valid.
+  // TODO(russr): Validate attribute names are legal and human readable.
+  static bool ValidateTestProperty(const internal::TestProperty& test_property);
+
+  // Returns the death test count.
+  int death_test_count() const { return death_test_count_; }
+
+  // Increments the death test count, returning the new count.
+  int increment_death_test_count() { return ++death_test_count_; }
+
+  // Clears the object.
+  void Clear();
+ private:
+  // Protects mutable state of the property list and of owned properties, whose
+  // values may be updated.
+  internal::Mutex test_properites_mutex_;
+
+  // The list of TestPartResults
+  internal::List<TestPartResult> test_part_results_;
+  // The list of TestProperties
+  internal::List<internal::TestProperty> test_properties_;
+  // Running count of death tests.
+  int death_test_count_;
+  // The elapsed time, in milliseconds.
+  TimeInMillis elapsed_time_;
+
+  // We disallow copying TestResult.
+  GTEST_DISALLOW_COPY_AND_ASSIGN(TestResult);
+};  // class TestResult
+
+class TestInfoImpl {
+ public:
+  TestInfoImpl(TestInfo* parent, const char* test_case_name,
+               const char* name, TypeId fixture_class_id,
+               TestMaker maker);
+  ~TestInfoImpl();
+
+  // Returns true if this test should run.
+  bool should_run() const { return should_run_; }
+
+  // Sets the should_run member.
+  void set_should_run(bool should) { should_run_ = should; }
+
+  // Returns true if this test is disabled. Disabled tests are not run.
+  bool is_disabled() const { return is_disabled_; }
+
+  // Sets the is_disabled member.
+  void set_is_disabled(bool is) { is_disabled_ = is; }
+
+  // Returns the test case name.
+  const char* test_case_name() const { return test_case_name_.c_str(); }
+
+  // Returns the test name.
+  const char* name() const { return name_.c_str(); }
+
+  // Returns the ID of the test fixture class.
+  TypeId fixture_class_id() const { return fixture_class_id_; }
+
+  // Returns the test result.
+  internal::TestResult* result() { return &result_; }
+  const internal::TestResult* result() const { return &result_; }
+
+  // Creates the test object, runs it, records its result, and then
+  // deletes it.
+  void Run();
+
+  // Calls the given TestInfo object's Run() method.
+  static void RunTest(TestInfo * test_info) {
+    test_info->impl()->Run();
+  }
+
+  // Clears the test result.
+  void ClearResult() { result_.Clear(); }
+
+  // Clears the test result in the given TestInfo object.
+  static void ClearTestResult(TestInfo * test_info) {
+    test_info->impl()->ClearResult();
+  }
+
+ private:
+  // These fields are immutable properties of the test.
+  TestInfo* const parent_;         // The owner of this object
+  const String test_case_name_;    // Test case name
+  const String name_;              // Test name
+  const TypeId fixture_class_id_;  // ID of the test fixture class
+  bool should_run_;                // True iff this test should run
+  bool is_disabled_;               // True iff this test is disabled
+  const TestMaker maker_;          // The function that creates the test object
+
+  // This field is mutable and needs to be reset before running the
+  // test for the second time.
+  internal::TestResult result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN(TestInfoImpl);
+};
+
+}  // namespace internal
+
+// A test case, which consists of a list of TestInfos.
+//
+// TestCase is not copyable.
+class TestCase {
+ public:
+  // Creates a TestCase with the given name.
+  //
+  // TestCase does NOT have a default constructor.  Always use this
+  // constructor to create a TestCase object.
+  //
+  // Arguments:
+  //
+  //   name:         name of the test case
+  //   set_up_tc:    pointer to the function that sets up the test case
+  //   tear_down_tc: pointer to the function that tears down the test case
+  TestCase(const char* name,
+           Test::SetUpTestCaseFunc set_up_tc,
+           Test::TearDownTestCaseFunc tear_down_tc);
+
+  // Destructor of TestCase.
+  virtual ~TestCase();
+
+  // Gets the name of the TestCase.
+  const char* name() const { return name_.c_str(); }
+
+  // Returns true if any test in this test case should run.
+  bool should_run() const { return should_run_; }
+
+  // Sets the should_run member.
+  void set_should_run(bool should) { should_run_ = should; }
+
+  // Gets the (mutable) list of TestInfos in this TestCase.
+  internal::List<TestInfo*>& test_info_list() { return *test_info_list_; }
+
+  // Gets the (immutable) list of TestInfos in this TestCase.
+  const internal::List<TestInfo *> & test_info_list() const {
+    return *test_info_list_;
+  }
+
+  // Gets the number of successful tests in this test case.
+  int successful_test_count() const;
+
+  // Gets the number of failed tests in this test case.
+  int failed_test_count() const;
+
+  // Gets the number of disabled tests in this test case.
+  int disabled_test_count() const;
+
+  // Get the number of tests in this test case that should run.
+  int test_to_run_count() const;
+
+  // Gets the number of all tests in this test case.
+  int total_test_count() const;
+
+  // Returns true iff the test case passed.
+  bool Passed() const { return !Failed(); }
+
+  // Returns true iff the test case failed.
+  bool Failed() const { return failed_test_count() > 0; }
+
+  // Returns the elapsed time, in milliseconds.
+  internal::TimeInMillis elapsed_time() const { return elapsed_time_; }
+
+  // Adds a TestInfo to this test case.  Will delete the TestInfo upon
+  // destruction of the TestCase object.
+  void AddTestInfo(TestInfo * test_info);
+
+  // Finds and returns a TestInfo with the given name.  If one doesn't
+  // exist, returns NULL.
+  TestInfo* GetTestInfo(const char* test_name);
+
+  // Clears the results of all tests in this test case.
+  void ClearResult();
+
+  // Clears the results of all tests in the given test case.
+  static void ClearTestCaseResult(TestCase* test_case) {
+    test_case->ClearResult();
+  }
+
+  // Runs every test in this TestCase.
+  void Run();
+
+  // Runs every test in the given TestCase.
+  static void RunTestCase(TestCase * test_case) { test_case->Run(); }
+
+  // Returns true iff test passed.
+  static bool TestPassed(const TestInfo * test_info) {
+    const internal::TestInfoImpl* const impl = test_info->impl();
+    return impl->should_run() && impl->result()->Passed();
+  }
+
+  // Returns true iff test failed.
+  static bool TestFailed(const TestInfo * test_info) {
+    const internal::TestInfoImpl* const impl = test_info->impl();
+    return impl->should_run() && impl->result()->Failed();
+  }
+
+  // Returns true iff test is disabled.
+  static bool TestDisabled(const TestInfo * test_info) {
+    return test_info->impl()->is_disabled();
+  }
+
+  // Returns true if the given test should run.
+  static bool ShouldRunTest(const TestInfo *test_info) {
+    return test_info->impl()->should_run();
+  }
+
+ private:
+  // Name of the test case.
+  internal::String name_;
+  // List of TestInfos.
+  internal::List<TestInfo*>* test_info_list_;
+  // Pointer to the function that sets up the test case.
+  Test::SetUpTestCaseFunc set_up_tc_;
+  // Pointer to the function that tears down the test case.
+  Test::TearDownTestCaseFunc tear_down_tc_;
+  // True iff any test in this test case should run.
+  bool should_run_;
+  // Elapsed time, in milliseconds.
+  internal::TimeInMillis elapsed_time_;
+
+  // We disallow copying TestCases.
+  GTEST_DISALLOW_COPY_AND_ASSIGN(TestCase);
+};
+
+namespace internal {
+
+// Class UnitTestOptions.
+//
+// This class contains functions for processing options the user
+// specifies when running the tests.  It has only static members.
+//
+// In most cases, the user can specify an option using either an
+// environment variable or a command line flag.  E.g. you can set the
+// test filter using either GTEST_FILTER or --gtest_filter.  If both
+// the variable and the flag are present, the latter overrides the
+// former.
+class UnitTestOptions {
+ public:
+  // Functions for processing the gtest_output flag.
+
+  // Returns the output format, or "" for normal printed output.
+  static String GetOutputFormat();
+
+  // Returns the name of the requested output file, or the default if none
+  // was explicitly specified.
+  static String GetOutputFile();
+
+  // Functions for processing the gtest_filter flag.
+
+  // Returns true iff the wildcard pattern matches the string.  The
+  // first ':' or '\0' character in pattern marks the end of it.
+  //
+  // This recursive algorithm isn't very efficient, but is clear and
+  // works well enough for matching test names, which are short.
+  static bool PatternMatchesString(const char *pattern, const char *str);
+
+  // Returns true iff the user-specified filter matches the test case
+  // name and the test name.
+  static bool FilterMatchesTest(const String &test_case_name,
+                                const String &test_name);
+
+#ifdef GTEST_OS_WINDOWS
+  // Function for supporting the gtest_catch_exception flag.
+
+  // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
+  // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
+  // This function is useful as an __except condition.
+  static int GTestShouldProcessSEH(DWORD exception_code);
+#endif  // GTEST_OS_WINDOWS
+ private:
+  // Returns true if "name" matches the ':' separated list of glob-style
+  // filters in "filter".
+  static bool MatchesFilter(const String& name, const char* filter);
+};
+
+// Returns the current application's name, removing directory path if that
+// is present.  Used by UnitTestOptions::GetOutputFile.
+FilePath GetCurrentExecutableName();
+
+// The role interface for getting the OS stack trace as a string.
+class OsStackTraceGetterInterface {
+ public:
+  OsStackTraceGetterInterface() {}
+  virtual ~OsStackTraceGetterInterface() {}
+
+  // Returns the current OS stack trace as a String.  Parameters:
+  //
+  //   max_depth  - the maximum number of stack frames to be included
+  //                in the trace.
+  //   skip_count - the number of top frames to be skipped; doesn't count
+  //                against max_depth.
+  virtual String CurrentStackTrace(int max_depth, int skip_count) = 0;
+
+  // UponLeavingGTest() should be called immediately before Google Test calls
+  // user code. It saves some information about the current stack that
+  // CurrentStackTrace() will use to find and hide Google Test stack frames.
+  virtual void UponLeavingGTest() = 0;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN(OsStackTraceGetterInterface);
+};
+
+// A working implemenation of the OsStackTraceGetterInterface interface.
+class OsStackTraceGetter : public OsStackTraceGetterInterface {
+ public:
+  OsStackTraceGetter() {}
+  virtual String CurrentStackTrace(int max_depth, int skip_count);
+  virtual void UponLeavingGTest();
+
+  // This string is inserted in place of stack frames that are part of
+  // Google Test's implementation.
+  static const char* const kElidedFramesMarker;
+
+ private:
+  Mutex mutex_;  // protects all internal state
+
+  // We save the stack frame below the frame that calls user code.
+  // We do this because the address of the frame immediately below
+  // the user code changes between the call to UponLeavingGTest()
+  // and any calls to CurrentStackTrace() from within the user code.
+  void* caller_frame_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN(OsStackTraceGetter);
+};
+
+// Information about a Google Test trace point.
+struct TraceInfo {
+  const char* file;
+  int line;
+  String message;
+};
+
+// The private implementation of the UnitTest class.  We don't protect
+// the methods under a mutex, as this class is not accessible by a
+// user and the UnitTest class that delegates work to this class does
+// proper locking.
+class UnitTestImpl : public TestPartResultReporterInterface {
+ public:
+  explicit UnitTestImpl(UnitTest* parent);
+  virtual ~UnitTestImpl();
+
+  // Reports a test part result.  This method is from the
+  // TestPartResultReporterInterface interface.
+  virtual void ReportTestPartResult(const TestPartResult& result);
+
+  // Returns the current test part result reporter.
+  TestPartResultReporterInterface* test_part_result_reporter();
+
+  // Sets the current test part result reporter.
+  void set_test_part_result_reporter(TestPartResultReporterInterface* reporter);
+
+  // Gets the number of successful test cases.
+  int successful_test_case_count() const;
+
+  // Gets the number of failed test cases.
+  int failed_test_case_count() const;
+
+  // Gets the number of all test cases.
+  int total_test_case_count() const;
+
+  // Gets the number of all test cases that contain at least one test
+  // that should run.
+  int test_case_to_run_count() const;
+
+  // Gets the number of successful tests.
+  int successful_test_count() const;
+
+  // Gets the number of failed tests.
+  int failed_test_count() const;
+
+  // Gets the number of disabled tests.
+  int disabled_test_count() const;
+
+  // Gets the number of all tests.
+  int total_test_count() const;
+
+  // Gets the number of tests that should run.
+  int test_to_run_count() const;
+
+  // Gets the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const { return elapsed_time_; }
+
+  // Returns true iff the unit test passed (i.e. all test cases passed).
+  bool Passed() const { return !Failed(); }
+
+  // Returns true iff the unit test failed (i.e. some test case failed
+  // or something outside of all tests failed).
+  bool Failed() const {
+    return failed_test_case_count() > 0 || ad_hoc_test_result()->Failed();
+  }
+
+  // Returns the TestResult for the test that's currently running, or
+  // the TestResult for the ad hoc test if no test is running.
+  internal::TestResult* current_test_result();
+
+  // Returns the TestResult for the ad hoc test.
+  const internal::TestResult* ad_hoc_test_result() const {
+    return &ad_hoc_test_result_;
+  }
+
+  // Sets the unit test result printer.
+  //
+  // Does nothing if the input and the current printer object are the
+  // same; otherwise, deletes the old printer object and makes the
+  // input the current printer.
+  void set_result_printer(UnitTestEventListenerInterface * result_printer);
+
+  // Returns the current unit test result printer if it is not NULL;
+  // otherwise, creates an appropriate result printer, makes it the
+  // current printer, and returns it.
+  UnitTestEventListenerInterface* result_printer();
+
+  // Sets the OS stack trace getter.
+  //
+  // Does nothing if the input and the current OS stack trace getter
+  // are the same; otherwise, deletes the old getter and makes the
+  // input the current getter.
+  void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter);
+
+  // Returns the current OS stack trace getter if it is not NULL;
+  // otherwise, creates an OsStackTraceGetter, makes it the current
+  // getter, and returns it.
+  OsStackTraceGetterInterface* os_stack_trace_getter();
+
+  // Returns the current OS stack trace as a String.
+  //
+  // The maximum number of stack frames to be included is specified by
+  // the gtest_stack_trace_depth flag.  The skip_count parameter
+  // specifies the number of top frames to be skipped, which doesn't
+  // count against the number of frames to be included.
+  //
+  // For example, if Foo() calls Bar(), which in turn calls
+  // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
+  // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
+  String CurrentOsStackTraceExceptTop(int skip_count);
+
+  // Finds and returns a TestCase with the given name.  If one doesn't
+  // exist, creates one and returns it.
+  //
+  // Arguments:
+  //
+  //   test_case_name: name of the test case
+  //   set_up_tc:      pointer to the function that sets up the test case
+  //   tear_down_tc:   pointer to the function that tears down the test case
+  TestCase* GetTestCase(const char* test_case_name,
+                        Test::SetUpTestCaseFunc set_up_tc,
+                        Test::TearDownTestCaseFunc tear_down_tc);
+
+  // Adds a TestInfo to the unit test.
+  //
+  // Arguments:
+  //
+  //   set_up_tc:    pointer to the function that sets up the test case
+  //   tear_down_tc: pointer to the function that tears down the test case
+  //   test_info:    the TestInfo object
+  void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc,
+                   Test::TearDownTestCaseFunc tear_down_tc,
+                   TestInfo * test_info) {
+    GetTestCase(test_info->test_case_name(),
+                set_up_tc,
+                tear_down_tc)->AddTestInfo(test_info);
+  }
+
+  // Sets the TestCase object for the test that's currently running.
+  void set_current_test_case(TestCase* current_test_case) {
+    current_test_case_ = current_test_case;
+  }
+
+  // Sets the TestInfo object for the test that's currently running.  If
+  // current_test_info is NULL, the assertion results will be stored in
+  // ad_hoc_test_result_.
+  void set_current_test_info(TestInfo* current_test_info) {
+    current_test_info_ = current_test_info;
+  }
+
+  // Runs all tests in this UnitTest object, prints the result, and
+  // returns 0 if all tests are successful, or 1 otherwise.  If any
+  // exception is thrown during a test on Windows, this test is
+  // considered to be failed, but the rest of the tests will still be
+  // run.  (We disable exceptions on Linux and Mac OS X, so the issue
+  // doesn't apply there.)
+  int RunAllTests();
+
+  // Clears the results of all tests, including the ad hoc test.
+  void ClearResult() {
+    test_cases_.ForEach(TestCase::ClearTestCaseResult);
+    ad_hoc_test_result_.Clear();
+  }
+
+  // Matches the full name of each test against the user-specified
+  // filter to decide whether the test should run, then records the
+  // result in each TestCase and TestInfo object.
+  // Returns the number of tests that should run.
+  int FilterTests();
+
+  // Lists all the tests by name.
+  void ListAllTests();
+
+  const TestCase* current_test_case() const { return current_test_case_; }
+  TestInfo* current_test_info() { return current_test_info_; }
+  const TestInfo* current_test_info() const { return current_test_info_; }
+
+  // Returns the list of environments that need to be set-up/torn-down
+  // before/after the tests are run.
+  internal::List<Environment*>* environments() { return &environments_; }
+  internal::List<Environment*>* environments_in_reverse_order() {
+    return &environments_in_reverse_order_;
+  }
+
+  internal::List<TestCase*>* test_cases() { return &test_cases_; }
+  const internal::List<TestCase*>* test_cases() const { return &test_cases_; }
+
+  // Getters for the per-thread Google Test trace stack.
+  internal::List<TraceInfo>* gtest_trace_stack() {
+    return gtest_trace_stack_.pointer();
+  }
+  const internal::List<TraceInfo>* gtest_trace_stack() const {
+    return gtest_trace_stack_.pointer();
+  }
+
+#ifdef GTEST_HAS_DEATH_TEST
+  // Returns a pointer to the parsed --gtest_internal_run_death_test
+  // flag, or NULL if that flag was not specified.
+  // This information is useful only in a death test child process.
+  const InternalRunDeathTestFlag* internal_run_death_test_flag() const {
+    return internal_run_death_test_flag_.get();
+  }
+
+  // Returns a pointer to the current death test factory.
+  internal::DeathTestFactory* death_test_factory() {
+    return death_test_factory_.get();
+  }
+
+  friend class ReplaceDeathTestFactory;
+#endif  // GTEST_HAS_DEATH_TEST
+
+ private:
+  // The UnitTest object that owns this implementation object.
+  UnitTest* const parent_;
+
+  // Points to (but doesn't own) the test part result reporter.
+  TestPartResultReporterInterface* test_part_result_reporter_;
+
+  // The list of environments that need to be set-up/torn-down
+  // before/after the tests are run.  environments_in_reverse_order_
+  // simply mirrors environments_ in reverse order.
+  internal::List<Environment*> environments_;
+  internal::List<Environment*> environments_in_reverse_order_;
+
+  internal::List<TestCase*> test_cases_;  // The list of TestCases.
+
+  // Points to the last death test case registered.  Initially NULL.
+  internal::ListNode<TestCase*>* last_death_test_case_;
+
+  // This points to the TestCase for the currently running test.  It
+  // changes as Google Test goes through one test case after another.
+  // When no test is running, this is set to NULL and Google Test
+  // stores assertion results in ad_hoc_test_result_.  Initally NULL.
+  TestCase* current_test_case_;
+
+  // This points to the TestInfo for the currently running test.  It
+  // changes as Google Test goes through one test after another.  When
+  // no test is running, this is set to NULL and Google Test stores
+  // assertion results in ad_hoc_test_result_.  Initially NULL.
+  TestInfo* current_test_info_;
+
+  // Normally, a user only writes assertions inside a TEST or TEST_F,
+  // or inside a function called by a TEST or TEST_F.  Since Google
+  // Test keeps track of which test is current running, it can
+  // associate such an assertion with the test it belongs to.
+  //
+  // If an assertion is encountered when no TEST or TEST_F is running,
+  // Google Test attributes the assertion result to an imaginary "ad hoc"
+  // test, and records the result in ad_hoc_test_result_.
+  internal::TestResult ad_hoc_test_result_;
+
+  // The unit test result printer.  Will be deleted when the UnitTest
+  // object is destructed.  By default, a plain text printer is used,
+  // but the user can set this field to use a custom printer if that
+  // is desired.
+  UnitTestEventListenerInterface* result_printer_;
+
+  // The OS stack trace getter.  Will be deleted when the UnitTest
+  // object is destructed.  By default, an OsStackTraceGetter is used,
+  // but the user can set this field to use a custom getter if that is
+  // desired.
+  OsStackTraceGetterInterface* os_stack_trace_getter_;
+
+  // How long the test took to run, in milliseconds.
+  TimeInMillis elapsed_time_;
+
+#ifdef GTEST_HAS_DEATH_TEST
+  // The decomposed components of the gtest_internal_run_death_test flag,
+  // parsed when RUN_ALL_TESTS is called.
+  internal::scoped_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_;
+  internal::scoped_ptr<internal::DeathTestFactory> death_test_factory_;
+#endif  // GTEST_HAS_DEATH_TEST
+
+  // A per-thread stack of traces created by the SCOPED_TRACE() macro.
+  internal::ThreadLocal<internal::List<TraceInfo> > gtest_trace_stack_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN(UnitTestImpl);
+};  // class UnitTestImpl
+
+// Convenience function for accessing the global UnitTest
+// implementation object.
+inline UnitTestImpl* GetUnitTestImpl() {
+  return UnitTest::GetInstance()->impl();
+}
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_SRC_GTEST_INTERNAL_INL_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/headerparser.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/headerparser.cc
new file mode 100644
index 0000000..f9b14db
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/headerparser.cc
@@ -0,0 +1,323 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <config.h>
+#include "headerparser.h"
+#include "logging.h"
+#include "varint_bigendian.h"
+#include "vcdiff_defs.h"
+
+namespace open_vcdiff {
+
+// *** Methods for ParseableChunk
+
+void ParseableChunk::Advance(size_t number_of_bytes) {
+  if (number_of_bytes > UnparsedSize()) {
+    LOG(DFATAL) << "Internal error: position advanced by " << number_of_bytes
+                << " bytes, current unparsed size " << UnparsedSize()
+                << LOG_ENDL;
+    position_ = end_;
+    return;
+  }
+  position_ += number_of_bytes;
+}
+
+void ParseableChunk::SetPosition(const char* position) {
+  if (position < start_) {
+    LOG(DFATAL) << "Internal error: new data position " << position
+                << " is beyond start of data " << start_ << LOG_ENDL;
+    position_ = start_;
+    return;
+  }
+  if (position > end_) {
+    LOG(DFATAL) << "Internal error: new data position " << position
+                << " is beyond end of data " << end_ << LOG_ENDL;
+    position_ = end_;
+    return;
+  }
+  position_ = position;
+}
+
+void ParseableChunk::FinishExcept(size_t number_of_bytes) {
+  if (number_of_bytes > UnparsedSize()) {
+    LOG(DFATAL) << "Internal error: specified number of remaining bytes "
+                << number_of_bytes << " is greater than unparsed data size "
+                << UnparsedSize() << LOG_ENDL;
+    Finish();
+    return;
+  }
+  position_ = end_ - number_of_bytes;
+}
+
+// *** Methods for VCDiffHeaderParser
+
+VCDiffHeaderParser::VCDiffHeaderParser(const char* header_start,
+                                       const char* data_end)
+    : parseable_chunk_(header_start, data_end - header_start),
+      return_code_(RESULT_SUCCESS),
+      delta_encoding_length_(0),
+      delta_encoding_start_(NULL) { }
+
+bool VCDiffHeaderParser::ParseByte(unsigned char* value) {
+  if (RESULT_SUCCESS != return_code_) {
+    return false;
+  }
+  if (parseable_chunk_.Empty()) {
+    return_code_ = RESULT_END_OF_DATA;
+    return false;
+  }
+  *value = static_cast<unsigned char>(*parseable_chunk_.UnparsedData());
+  parseable_chunk_.Advance(1);
+  return true;
+}
+
+bool VCDiffHeaderParser::ParseInt32(const char* variable_description,
+                                    int32_t* value) {
+  if (RESULT_SUCCESS != return_code_) {
+    return false;
+  }
+  int32_t parsed_value =
+      VarintBE<int32_t>::Parse(parseable_chunk_.End(),
+                               parseable_chunk_.UnparsedDataAddr());
+  switch (parsed_value) {
+    case RESULT_ERROR:
+      LOG(ERROR) << "Expected " << variable_description
+                 << "; found invalid variable-length integer" << LOG_ENDL;
+      return_code_ = RESULT_ERROR;
+      return false;
+    case RESULT_END_OF_DATA:
+      return_code_ = RESULT_END_OF_DATA;
+      return false;
+    default:
+      *value = parsed_value;
+      return true;
+  }
+}
+
+// When an unsigned 32-bit integer is expected, parse a signed 64-bit value
+// instead, then check the value limit.  The uint32_t type can't be parsed
+// directly because two negative values are given special meanings (RESULT_ERROR
+// and RESULT_END_OF_DATA) and could not be expressed in an unsigned format.
+bool VCDiffHeaderParser::ParseUInt32(const char* variable_description,
+                                     uint32_t* value) {
+  if (RESULT_SUCCESS != return_code_) {
+    return false;
+  }
+  int64_t parsed_value =
+      VarintBE<int64_t>::Parse(parseable_chunk_.End(),
+                               parseable_chunk_.UnparsedDataAddr());
+  switch (parsed_value) {
+    case RESULT_ERROR:
+      LOG(ERROR) << "Expected " << variable_description
+                 << "; found invalid variable-length integer" << LOG_ENDL;
+      return_code_ = RESULT_ERROR;
+      return false;
+    case RESULT_END_OF_DATA:
+      return_code_ = RESULT_END_OF_DATA;
+      return false;
+    default:
+      if (parsed_value > 0xFFFFFFFF) {
+        LOG(ERROR) << "Value of " << variable_description << "(" << parsed_value
+                   << ") is too large for unsigned 32-bit integer" << LOG_ENDL;
+        return_code_ = RESULT_ERROR;
+        return false;
+      }
+      *value = static_cast<uint32_t>(parsed_value);
+      return true;
+  }
+}
+
+// A VCDChecksum represents an unsigned 32-bit value returned by adler32(),
+// but isn't a uint32_t.
+bool VCDiffHeaderParser::ParseChecksum(const char* variable_description,
+                                       VCDChecksum* value) {
+  uint32_t parsed_value = 0;
+  if (!ParseUInt32(variable_description, &parsed_value)) {
+    return false;
+  }
+  *value = static_cast<VCDChecksum>(parsed_value);
+  return true;
+}
+
+bool VCDiffHeaderParser::ParseSize(const char* variable_description,
+                                   size_t* value) {
+  int32_t parsed_value = 0;
+  if (!ParseInt32(variable_description, &parsed_value)) {
+    return false;
+  }
+  *value = static_cast<size_t>(parsed_value);
+  return true;
+}
+
+bool VCDiffHeaderParser::ParseSourceSegmentLengthAndPosition(
+    size_t from_size,
+    const char* from_boundary_name,
+    const char* from_name,
+    size_t* source_segment_length,
+    size_t* source_segment_position) {
+  // Verify the length and position values
+  if (!ParseSize("source segment length", source_segment_length)) {
+    return false;
+  }
+  // Guard against overflow by checking source length first
+  if (*source_segment_length > from_size) {
+    LOG(ERROR) << "Source segment length (" << *source_segment_length
+               << ") is larger than " << from_name << " (" << from_size
+               << ")" << LOG_ENDL;
+    return_code_ = RESULT_ERROR;
+    return false;
+  }
+  if (!ParseSize("source segment position", source_segment_position)) {
+    return false;
+  }
+  if ((*source_segment_position >= from_size) &&
+      (*source_segment_length > 0)) {
+    LOG(ERROR) << "Source segment position (" << *source_segment_position
+               << ") is past " << from_boundary_name
+               << " (" << from_size << ")" << LOG_ENDL;
+    return_code_ = RESULT_ERROR;
+    return false;
+  }
+  const size_t source_segment_end = *source_segment_position +
+                                    *source_segment_length;
+  if (source_segment_end > from_size) {
+    LOG(ERROR) << "Source segment end position (" << source_segment_end
+               << ") is past " << from_boundary_name
+               << " (" << from_size << ")" << LOG_ENDL;
+    return_code_ = RESULT_ERROR;
+    return false;
+  }
+  return true;
+}
+
+bool VCDiffHeaderParser::ParseWinIndicatorAndSourceSegment(
+    size_t dictionary_size,
+    size_t decoded_target_size,
+    unsigned char* win_indicator,
+    size_t* source_segment_length,
+    size_t* source_segment_position) {
+  if (!ParseByte(win_indicator)) {
+    return false;
+  }
+  unsigned char source_target_flags =
+      *win_indicator & (VCD_SOURCE | VCD_TARGET);
+  switch (source_target_flags) {
+    case VCD_SOURCE:
+      return ParseSourceSegmentLengthAndPosition(dictionary_size,
+                                                 "end of dictionary",
+                                                 "dictionary",
+                                                 source_segment_length,
+                                                 source_segment_position);
+    case VCD_TARGET:
+      return ParseSourceSegmentLengthAndPosition(decoded_target_size,
+                                                 "current target position",
+                                                 "target file",
+                                                 source_segment_length,
+                                                 source_segment_position);
+    case VCD_SOURCE | VCD_TARGET:
+      LOG(ERROR) << "Win_Indicator must not have both VCD_SOURCE"
+                    " and VCD_TARGET set" << LOG_ENDL;
+      return_code_ = RESULT_ERROR;
+      return false;
+    default:
+      return true;
+  }
+}
+
+bool VCDiffHeaderParser::ParseWindowLengths(size_t* target_window_length) {
+  if (delta_encoding_start_) {
+    LOG(DFATAL) << "Internal error: VCDiffHeaderParser::ParseWindowLengths "
+                   "was called twice for the same delta window" << LOG_ENDL;
+    return_code_ = RESULT_ERROR;
+    return false;
+  }
+  if (!ParseSize("length of the delta encoding", &delta_encoding_length_)) {
+    return false;
+  }
+  delta_encoding_start_ = UnparsedData();
+  if (!ParseSize("size of the target window", target_window_length)) {
+    return false;
+  }
+  if (*target_window_length > kMaxTargetWindowSize) {
+    LOG(ERROR) << "Length of target window (" << (*target_window_length)
+               << ") exceeds limit of " << kMaxTargetWindowSize << " bytes"
+               << LOG_ENDL;
+    return_code_ = RESULT_ERROR;
+    return false;
+  }
+  return true;
+}
+
+const char* VCDiffHeaderParser::EndOfDeltaWindow() const {
+  if (!delta_encoding_start_) {
+    LOG(DFATAL) << "Internal error: VCDiffHeaderParser::GetDeltaWindowEnd "
+                   "was called before ParseWindowLengths" << LOG_ENDL;
+    return NULL;
+  }
+  return delta_encoding_start_ + delta_encoding_length_;
+}
+
+bool VCDiffHeaderParser::ParseDeltaIndicator() {
+  unsigned char delta_indicator;
+  if (!ParseByte(&delta_indicator)) {
+    return false;
+  }
+  if (delta_indicator & (VCD_DATACOMP | VCD_INSTCOMP | VCD_ADDRCOMP)) {
+    LOG(ERROR) << "Secondary compression of delta file sections "
+                  "is not supported" << LOG_ENDL;
+    return_code_ = RESULT_ERROR;
+    return false;
+  }
+  return true;
+}
+
+bool VCDiffHeaderParser::ParseSectionLengths(
+    bool has_checksum,
+    size_t* add_and_run_data_length,
+    size_t* instructions_and_sizes_length,
+    size_t* addresses_length,
+    VCDChecksum* checksum) {
+  ParseSize("length of data for ADDs and RUNs", add_and_run_data_length);
+  ParseSize("length of instructions section", instructions_and_sizes_length);
+  ParseSize("length of addresses for COPYs", addresses_length);
+  if (has_checksum) {
+    ParseChecksum("Adler32 checksum value", checksum);
+  }
+  if (RESULT_SUCCESS != return_code_) {
+    return false;
+  }
+  if (!delta_encoding_start_) {
+    LOG(DFATAL) << "Internal error: VCDiffHeaderParser::ParseSectionLengths "
+                   "was called before ParseWindowLengths" << LOG_ENDL;
+    return_code_ = RESULT_ERROR;
+    return false;
+  }
+  const size_t delta_encoding_header_length =
+      UnparsedData() - delta_encoding_start_;
+  if (delta_encoding_length_ !=
+          (delta_encoding_header_length +
+           *add_and_run_data_length +
+           *instructions_and_sizes_length +
+           *addresses_length)) {
+    LOG(ERROR) << "The length of the delta encoding does not match "
+                  "the size of the header plus the sizes of the data sections"
+               << LOG_ENDL;
+    return_code_ = RESULT_ERROR;
+    return false;
+  }
+  return true;
+}
+
+}  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/headerparser.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/headerparser.h
new file mode 100644
index 0000000..6271f0a
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/headerparser.h
@@ -0,0 +1,404 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OPEN_VCDIFF_HEADERPARSER_H_
+#define OPEN_VCDIFF_HEADERPARSER_H_
+
+#include <config.h>
+#include <stdint.h>  // int32_t, uint32_t
+#include <cstddef>  // NULL
+#include "checksum.h"  // VCDChecksum
+#include "vcdiff_defs.h"  // VCDiffResult
+
+namespace open_vcdiff {
+
+// This class contains a contiguous memory buffer with start and end pointers,
+// as well as a position pointer which shows how much of the buffer has been
+// parsed and how much remains.
+//
+// Because no virtual destructor is defined for ParseableChunk, a pointer to
+// a child class of ParseableChunk must be destroyed using its specific type,
+// rather than as a ParseableChunk*.
+class ParseableChunk {
+ public:
+  ParseableChunk(const char* data_start, size_t data_size) {
+    SetDataBuffer(data_start, data_size);
+  }
+
+  const char* End() const { return end_; }
+
+  // The number of bytes remaining to be parsed.  This is not necessarily the
+  // same as the initial size of the buffer; it changes with each call to
+  // Advance().
+  size_t UnparsedSize() const {
+    return end_ - position_;
+  }
+
+  // The number of bytes that have already been parsed.
+  size_t ParsedSize() const {
+    return position_ - start_;
+  }
+
+  bool Empty() const { return 0 == UnparsedSize(); }
+
+  // The start of the data remaining to be parsed.
+  const char* UnparsedData() const { return position_; }
+
+  // Returns a pointer to the start of the data remaining to be parsed.
+  const char** UnparsedDataAddr() { return &position_; }
+
+  // Moves the parsing position forward by number_of_bytes.
+  void Advance(size_t number_of_bytes);
+
+  // Jumps the parsing position to a new location.
+  void SetPosition(const char* position);
+
+  // Jumps the parsing position to the end of the data chunk.
+  void Finish() {
+    position_ = end_;
+  }
+
+  // Jumps the parsing position so that there are now number_of_bytes
+  // bytes left to parse.  This number should be smaller than the size of data
+  // to be parsed before the function was called.
+  void FinishExcept(size_t number_of_bytes);
+
+  void SetDataBuffer(const char* data_start, size_t data_size) {
+    start_ = data_start;
+    end_ = data_start + data_size;
+    position_ = start_;
+  }
+
+ private:
+  const char* start_;
+  const char* end_;
+
+  // The current parsing position within the data chunk.
+  // Must always respect start_ <= position_ <= end_.
+  const char* position_;
+
+  // Making these private avoids implicit copy constructor & assignment operator
+  ParseableChunk(const ParseableChunk&);
+  void operator=(const ParseableChunk&);
+};
+
+// Represents one of the three sections in the delta window, as described in
+// RFC section 4.3:
+//     * Data section for ADDs and RUNs
+//     * Instructions and sizes section
+//     * Addresses section for COPYs
+// When using the interleaved format, data and addresses are pulled from the
+// instructions and sizes section rather than being stored in separate sections.
+// For that reason, this class allows one DeltaWindowSection to be based on
+// another, such that the same position pointer is shared by both sections;
+// i.e., UnparsedDataAddr() returns the same value for both objects.
+// To achieve this end, one extra level of indirection (a pointer to a
+// ParseableChunk object) is added.
+class DeltaWindowSection {
+ public:
+  DeltaWindowSection() : parseable_chunk_(NULL), owned_(true) { }
+
+  ~DeltaWindowSection() {
+    FreeChunk();
+  }
+
+  void Init(const char* data_start, size_t data_size) {
+    if (owned_ && parseable_chunk_) {
+      // Reuse the already-allocated ParseableChunk object.
+      parseable_chunk_->SetDataBuffer(data_start, data_size);
+    } else {
+      parseable_chunk_ = new ParseableChunk(data_start, data_size);
+      owned_ = true;
+    }
+  }
+
+  void Init(DeltaWindowSection* original) {
+    FreeChunk();
+    parseable_chunk_ = original->parseable_chunk_;
+    owned_ = false;
+  }
+
+  void Invalidate() { FreeChunk(); }
+
+  bool IsOwned() const { return owned_; }
+
+  // The following functions just pass their arguments to the underlying
+  // ParseableChunk object.
+
+  const char* End() const {
+    return parseable_chunk_->End();
+  }
+
+  size_t UnparsedSize() const {
+    return parseable_chunk_->UnparsedSize();
+  }
+
+  size_t ParsedSize() const {
+    return parseable_chunk_->ParsedSize();
+  }
+
+  bool Empty() const {
+    return parseable_chunk_->Empty();
+  }
+
+  const char* UnparsedData() const {
+    return parseable_chunk_->UnparsedData();
+  }
+
+  const char** UnparsedDataAddr() {
+    return parseable_chunk_->UnparsedDataAddr();
+  }
+
+  void Advance(size_t number_of_bytes) {
+    return parseable_chunk_->Advance(number_of_bytes);
+  }
+ private:
+  void FreeChunk() {
+    if (owned_) {
+      delete parseable_chunk_;
+    }
+    parseable_chunk_ = NULL;
+  }
+
+  // Will be NULL until Init() has been called.  If owned_ is true, this will
+  // point to a ParseableChunk object that has been allocated with "new" and
+  // must be deleted by this DeltaWindowSection object.  If owned_ is false,
+  // this points at the parseable_chunk_ owned by a different DeltaWindowSection
+  // object.  In this case, it is important to free the DeltaWindowSection which
+  // does not own the ParseableChunk before (or simultaneously to) freeing the
+  // DeltaWindowSection that owns it, or else deleted memory may be accessed.
+  ParseableChunk* parseable_chunk_;
+  bool owned_;
+
+  // Making these private avoids implicit copy constructor & assignment operator
+  DeltaWindowSection(const DeltaWindowSection&);
+  void operator=(const DeltaWindowSection&);
+};
+
+// Used to parse the bytes and Varints that make up the delta file header
+// or delta window header.
+class VCDiffHeaderParser {
+ public:
+  // The maximum allowable size of a target window.  This restricts the amount
+  // of memory that can be allocated by the decoder.  A maliciously formulated
+  // delta file can create a target window of any arbitrary size, so the
+  // decoder needs to be sure that it can allocate this much memory using
+  // std::string::reserve().
+  //
+  static const size_t kMaxTargetWindowSize = 1 << 26;  // 64 MB
+
+  // header_start should be the start of the header to be parsed;
+  // data_end is the position just after the last byte of available data
+  // (which may extend far past the end of the header.)
+  VCDiffHeaderParser(const char* header_start, const char* data_end);
+
+  // One of these functions should be called for each element of the header.
+  // variable_description is a description of the value that we are attempting
+  // to parse, and will only be used to create descriptive error messages.
+  // If the function returns true, then the element was parsed successfully
+  // and its value has been placed in *value.  If the function returns false,
+  // then *value is unchanged, and GetResult() can be called to return the
+  // reason that the element could not be parsed, which will be either
+  // RESULT_ERROR (an error occurred), or RESULT_END_OF_DATA (the limit data_end
+  // was reached before the end of the element to be parsed.)  Once one of these
+  // functions has returned false, further calls to any of the Parse...
+  // functions will also return false without performing any additional actions.
+  // Typical usage is as follows:
+  //     int32_t segment_length = 0;
+  //     if (!header_parser.ParseInt32("segment length", &segment_length)) {
+  //       return header_parser.GetResult();
+  //     }
+  //
+  // The following example takes advantage of the fact that calling a Parse...
+  // function after an error or end-of-data condition is legal and does nothing.
+  // It can thus parse more than one element in a row and check the status
+  // afterwards.  If the first call to ParseInt32() fails, the second will have
+  // no effect:
+  //
+  //     int32_t segment_length = 0, segment_position = 0;
+  //     header_parser.ParseInt32("segment length", &segment_length));
+  //     header_parser.ParseInt32("segment position", &segment_position));
+  //     if (RESULT_SUCCESS != header_parser.GetResult()) {
+  //       return header_parser.GetResult();
+  //     }
+  //
+  bool ParseByte(unsigned char* value);
+  bool ParseInt32(const char* variable_description, int32_t* value);
+  bool ParseUInt32(const char* variable_description, uint32_t* value);
+  bool ParseChecksum(const char* variable_description, VCDChecksum* value);
+  bool ParseSize(const char* variable_description, size_t* value);
+
+  // Parses the first three elements of the delta window header:
+  //
+  //     Win_Indicator                            - byte
+  //     [Source segment size]                    - integer (VarintBE format)
+  //     [Source segment position]                - integer (VarintBE format)
+  //
+  // Returns true if the values were parsed successfully and the values were
+  // found to be acceptable.  Returns false otherwise, in which case
+  // GetResult() can be called to return the reason that the two values
+  // could not be validated.  This will be either RESULT_ERROR (an error
+  // occurred and was logged), or RESULT_END_OF_DATA (the limit data_end was
+  // reached before the end of the values to be parsed.)  If return value is
+  // true, then *win_indicator, *source_segment_length, and
+  // *source_segment_position are populated with the parsed values.  Otherwise,
+  // the values of these output arguments are undefined.
+  //
+  // dictionary_size: The size of the dictionary (source) file.  Used to
+  //     validate the limits of source_segment_length and
+  //     source_segment_position if the source segment is taken from the
+  //     dictionary (i.e., if the parsed *win_indicator equals VCD_SOURCE.)
+  // decoded_target_size: The size of the target data that has been decoded
+  //     so far, including all target windows.  Used to validate the limits of
+  //     source_segment_length and source_segment_position if the source segment
+  //     is taken from the target (i.e., if the parsed *win_indicator equals
+  //     VCD_TARGET.)
+  // win_indicator (output): Points to a single unsigned char (not an array)
+  //     that will receive the parsed value of Win_Indicator.
+  // source_segment_length (output): The parsed length of the source segment.
+  // source_segment_position (output): The parsed zero-based index in the
+  //     source/target file from which the source segment is to be taken.
+  bool ParseWinIndicatorAndSourceSegment(size_t dictionary_size,
+                                         size_t decoded_target_size,
+                                         unsigned char* win_indicator,
+                                         size_t* source_segment_length,
+                                         size_t* source_segment_position);
+
+  // Parses the following two elements of the delta window header:
+  //
+  //     Length of the delta encoding             - integer (VarintBE format)
+  //     Size of the target window                - integer (VarintBE format)
+  //
+  // Return conditions and values are the same as for
+  // ParseWinIndicatorAndSourceSegment(), above.
+  //
+  bool ParseWindowLengths(size_t* target_window_length);
+
+  // May only be called after ParseWindowLengths() has returned RESULT_SUCCESS.
+  // Returns a pointer to the end of the delta window (which might not point to
+  // a valid memory location if there is insufficient input data.)
+  //
+  const char* EndOfDeltaWindow() const;
+
+  // Parses the following element of the delta window header:
+  //
+  //     Delta_Indicator                          - byte
+  //
+  // Because none of the bits in Delta_Indicator are used by this implementation
+  // of VCDIFF, this function does not have an output argument to return the
+  // value of that field.  It may return RESULT_SUCCESS, RESULT_ERROR, or
+  // RESULT_END_OF_DATA as with the other Parse...() functions.
+  //
+  bool ParseDeltaIndicator();
+
+  // Parses the following 3 elements of the delta window header:
+  //
+  //     Length of data for ADDs and RUNs - integer (VarintBE format)
+  //     Length of instructions and sizes - integer (VarintBE format)
+  //     Length of addresses for COPYs    - integer (VarintBE format)
+  //
+  // If has_checksum is true, it also looks for the following element:
+  //
+  //     Adler32 checksum            - unsigned 32-bit integer (VarintBE format)
+  //
+  // Return conditions and values are the same as for
+  // ParseWinIndicatorAndSourceSegment(), above.
+  //
+  bool ParseSectionLengths(bool has_checksum,
+                           size_t* add_and_run_data_length,
+                           size_t* instructions_and_sizes_length,
+                           size_t* addresses_length,
+                           VCDChecksum* checksum);
+
+  // If one of the Parse... functions returned false, this function
+  // can be used to find the result code (RESULT_ERROR or RESULT_END_OF_DATA)
+  // describing the reason for the most recent parse failure.  If none of the
+  // Parse... functions has returned false, returns RESULT_SUCCESS.
+  VCDiffResult GetResult() const {
+    return return_code_;
+  }
+
+  // The following functions just pass their arguments to the underlying
+  // ParseableChunk object.
+
+  const char* End() const {
+    return parseable_chunk_.End();
+  }
+
+  size_t UnparsedSize() const {
+    return parseable_chunk_.UnparsedSize();
+  }
+
+  size_t ParsedSize() const {
+    return parseable_chunk_.ParsedSize();
+  }
+
+  const char* UnparsedData() const {
+    return parseable_chunk_.UnparsedData();
+  }
+
+ private:
+  // Parses two variable-length integers representing the source segment length
+  // and source segment position (== offset.)  Checks whether the source segment
+  // length and position would cause it to exceed the size of the source file or
+  // target file.  Returns true if the values were parsed successfully and the
+  // values were found to be acceptable.  Returns false otherwise, in which case
+  // GetResult() can be called to return the reason that the two values could
+  // not be validated, which will be either RESULT_ERROR (an error occurred and
+  // was logged), or RESULT_END_OF_DATA (the limit data_end was reached before
+  // the end of the integers to be parsed.)
+  // from_size: The requested size of the source segment.
+  // from_boundary_name: A NULL-terminated string naming the end of the
+  //     source or target file, used in error messages.
+  // from_name: A NULL-terminated string naming the source or target file,
+  //     also used in error messages.
+  // source_segment_length (output): The parsed length of the source segment.
+  // source_segment_position (output): The parsed zero-based index in the
+  //     source/target file from which the source segment is to be taken.
+  //
+  bool ParseSourceSegmentLengthAndPosition(size_t from_size,
+                                           const char* from_boundary_name,
+                                           const char* from_name,
+                                           size_t* source_segment_length,
+                                           size_t* source_segment_position);
+
+  ParseableChunk parseable_chunk_;
+
+  // Contains the result code of the last Parse...() operation that failed
+  // (RESULT_ERROR or RESULT_END_OF_DATA).  If no Parse...() method has been
+  // called, or if all calls to Parse...() were successful, then this contains
+  // RESULT_SUCCESS.
+  VCDiffResult return_code_;
+
+  // Will be zero until ParseWindowLengths() has been called.  After
+  // ParseWindowLengths() has been called successfully, this contains the
+  // parsed length of the delta encoding.
+  size_t delta_encoding_length_;
+
+  // Will be NULL until ParseWindowLengths() has been called.  After
+  // ParseWindowLengths() has been called successfully, this points to the
+  // beginning of the section of the current window titled "The delta encoding"
+  // in the RFC, i.e., to the position just after the length of the delta
+  // encoding.
+  const char* delta_encoding_start_;
+
+  // Making these private avoids implicit copy constructor & assignment operator
+  VCDiffHeaderParser(const VCDiffHeaderParser&);
+  void operator=(const VCDiffHeaderParser&);
+};
+
+}  // namespace open_vcdiff
+
+#endif  // OPEN_VCDIFF_HEADERPARSER_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/headerparser_test.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/headerparser_test.cc
new file mode 100644
index 0000000..30a7519
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/headerparser_test.cc
@@ -0,0 +1,209 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <config.h>
+#include "headerparser.h"
+#include <cstdlib>  // rand, srand
+#include <string>
+#include <vector>
+#include "testing.h"
+#include "varint_bigendian.h"
+
+namespace open_vcdiff {
+namespace {  // anonymous
+
+using std::string;
+using std::vector;
+
+class VCDiffHeaderParserTest : public testing::Test {
+ protected:
+  static const int kTestSize = 1024;
+
+  VCDiffHeaderParserTest() : parser(NULL) { }
+
+  virtual ~VCDiffHeaderParserTest() {
+    delete parser;
+  }
+
+  virtual void SetUp() {
+    srand(1);  // make sure each test uses the same data set
+  }
+
+  void StartParsing() {
+    parser = new VCDiffHeaderParser(
+        encoded_buffer_.data(),
+        encoded_buffer_.data() + encoded_buffer_.size());
+    EXPECT_EQ(encoded_buffer_.data(), parser->UnparsedData());
+  }
+
+  void VerifyByte(unsigned char expected_value) {
+    unsigned char decoded_byte = 0;
+    const char* prior_position = parser->UnparsedData();
+    EXPECT_TRUE(parser->ParseByte(&decoded_byte));
+    EXPECT_EQ(expected_value, decoded_byte);
+    EXPECT_EQ(RESULT_SUCCESS, parser->GetResult());
+    EXPECT_EQ(prior_position + sizeof(unsigned char),
+              parser->UnparsedData());
+  }
+
+  void VerifyInt32(int32_t expected_value) {
+    int32_t decoded_integer = 0;
+    const char* prior_position = parser->UnparsedData();
+    EXPECT_TRUE(parser->ParseInt32("decoded int32", &decoded_integer));
+    EXPECT_EQ(expected_value, decoded_integer);
+    EXPECT_EQ(RESULT_SUCCESS, parser->GetResult());
+    EXPECT_EQ(prior_position + VarintBE<int32_t>::Length(decoded_integer),
+              parser->UnparsedData());
+  }
+
+  void VerifyUInt32(uint32_t expected_value) {
+    uint32_t decoded_integer = 0;
+    const char* prior_position = parser->UnparsedData();
+    EXPECT_TRUE(parser->ParseUInt32("decoded uint32", &decoded_integer));
+    EXPECT_EQ(expected_value, decoded_integer);
+    EXPECT_EQ(RESULT_SUCCESS, parser->GetResult());
+    EXPECT_EQ(prior_position + VarintBE<int64_t>::Length(decoded_integer),
+              parser->UnparsedData());
+  }
+
+  void VerifyChecksum(VCDChecksum expected_value) {
+    VCDChecksum decoded_checksum = 0;
+    const char* prior_position = parser->UnparsedData();
+    EXPECT_TRUE(parser->ParseChecksum("decoded checksum", &decoded_checksum));
+    EXPECT_EQ(expected_value, decoded_checksum);
+    EXPECT_EQ(RESULT_SUCCESS, parser->GetResult());
+    EXPECT_EQ(prior_position + VarintBE<int64_t>::Length(decoded_checksum),
+              parser->UnparsedData());
+  }
+
+  string encoded_buffer_;
+  VCDiffHeaderParser* parser;
+};
+
+TEST_F(VCDiffHeaderParserTest, ParseRandomBytes) {
+  vector<unsigned char> byte_values;
+  for (int i = 0; i < kTestSize; ++i) {
+    unsigned char random_byte = PortableRandomInRange<unsigned char>(0xFF);
+    encoded_buffer_.push_back(random_byte);
+    byte_values.push_back(random_byte);
+  }
+  StartParsing();
+  for (int position = 0; position < kTestSize; ++position) {
+    VerifyByte(byte_values[position]);
+  }
+  unsigned char decoded_byte = 0;
+  EXPECT_FALSE(parser->ParseByte(&decoded_byte));
+  EXPECT_EQ(RESULT_END_OF_DATA, parser->GetResult());
+  EXPECT_EQ(encoded_buffer_.data() + encoded_buffer_.size(),
+            parser->UnparsedData());
+}
+
+TEST_F(VCDiffHeaderParserTest, ParseRandomInt32) {
+  vector<int32_t> integer_values;
+  for (int i = 0; i < kTestSize; ++i) {
+    int32_t random_integer = PortableRandomInRange<int32_t>(0x7FFFFFFF);
+    VarintBE<int32_t>::AppendToString(random_integer, &encoded_buffer_);
+    integer_values.push_back(random_integer);
+  }
+  StartParsing();
+  for (int i = 0; i < kTestSize; ++i) {
+    VerifyInt32(integer_values[i]);
+  }
+  int32_t decoded_integer = 0;
+  EXPECT_FALSE(parser->ParseInt32("decoded integer", &decoded_integer));
+  EXPECT_EQ(RESULT_END_OF_DATA, parser->GetResult());
+  EXPECT_EQ(encoded_buffer_.data() + encoded_buffer_.size(),
+            parser->UnparsedData());
+}
+
+TEST_F(VCDiffHeaderParserTest, ParseRandomUInt32) {
+  vector<uint32_t> integer_values;
+  for (int i = 0; i < kTestSize; ++i) {
+    uint32_t random_integer = PortableRandomInRange<uint32_t>(0xFFFFFFFF);
+    VarintBE<int64_t>::AppendToString(random_integer, &encoded_buffer_);
+    integer_values.push_back(random_integer);
+  }
+  StartParsing();
+  uint32_t decoded_integer = 0;
+  for (int i = 0; i < kTestSize; ++i) {
+    VerifyUInt32(integer_values[i]);
+  }
+  EXPECT_FALSE(parser->ParseUInt32("decoded integer", &decoded_integer));
+  EXPECT_EQ(RESULT_END_OF_DATA, parser->GetResult());
+  EXPECT_EQ(encoded_buffer_.data() + encoded_buffer_.size(),
+            parser->UnparsedData());
+}
+
+TEST_F(VCDiffHeaderParserTest, ParseRandomChecksum) {
+  vector<VCDChecksum> checksum_values;
+  for (int i = 0; i < kTestSize; ++i) {
+    VCDChecksum random_checksum =
+        PortableRandomInRange<VCDChecksum>(0xFFFFFFFF);
+    VarintBE<int64_t>::AppendToString(random_checksum, &encoded_buffer_);
+    checksum_values.push_back(random_checksum);
+  }
+  StartParsing();
+  for (int i = 0; i < kTestSize; ++i) {
+    VerifyChecksum(checksum_values[i]);
+  }
+  VCDChecksum decoded_checksum = 0;
+  EXPECT_FALSE(parser->ParseChecksum("decoded checksum", &decoded_checksum));
+  EXPECT_EQ(RESULT_END_OF_DATA, parser->GetResult());
+  EXPECT_EQ(encoded_buffer_.data() + encoded_buffer_.size(),
+            parser->UnparsedData());
+}
+
+TEST_F(VCDiffHeaderParserTest, ParseMixed) {
+  VarintBE<int64_t>::AppendToString(0xCAFECAFE, &encoded_buffer_);
+  encoded_buffer_.push_back(0xFF);
+  VarintBE<int32_t>::AppendToString(0x02020202, &encoded_buffer_);
+  VarintBE<int64_t>::AppendToString(0xCAFECAFE, &encoded_buffer_);
+  encoded_buffer_.push_back(0xFF);
+  encoded_buffer_.push_back(0xFF);
+  StartParsing();
+  VerifyUInt32(0xCAFECAFE);
+  VerifyByte(0xFF);
+  VerifyInt32(0x02020202);
+  VerifyChecksum(0xCAFECAFE);
+  int32_t incomplete_int32 = 0;
+  EXPECT_FALSE(parser->ParseInt32("incomplete Varint", &incomplete_int32));
+  EXPECT_EQ(0, incomplete_int32);
+  EXPECT_EQ(RESULT_END_OF_DATA, parser->GetResult());
+  EXPECT_EQ(encoded_buffer_.data() + encoded_buffer_.size() - 2,
+            parser->UnparsedData());
+}
+
+TEST_F(VCDiffHeaderParserTest, ParseInvalidVarint) {
+  // Start with a byte that has the continuation bit plus a high-order bit set
+  encoded_buffer_.append(1, static_cast<char>(0xC0));
+  // Add too many bytes with continuation bits
+  encoded_buffer_.append(6, static_cast<char>(0x80));
+  StartParsing();
+  int32_t invalid_int32 = 0;
+  EXPECT_FALSE(parser->ParseInt32("invalid Varint", &invalid_int32));
+  EXPECT_EQ(0, invalid_int32);
+  EXPECT_EQ(RESULT_ERROR, parser->GetResult());
+  EXPECT_EQ(encoded_buffer_.data(), parser->UnparsedData());
+  // After the parse failure, any other call to Parse... should return an error,
+  // even though there is still a byte that could be read as valid.
+  unsigned char decoded_byte = 0;
+  EXPECT_FALSE(parser->ParseByte(&decoded_byte));
+  EXPECT_EQ(0, decoded_byte);
+  EXPECT_EQ(RESULT_ERROR, parser->GetResult());
+  EXPECT_EQ(encoded_buffer_.data(), parser->UnparsedData());
+}
+
+}  //  namespace open_vcdiff
+}  //  anonymous namespace
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/logging.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/logging.cc
new file mode 100644
index 0000000..cdcc42b
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/logging.cc
@@ -0,0 +1,26 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <config.h>
+#include "logging.h"
+
+namespace open_vcdiff {
+
+bool g_fatal_error_occurred = false;
+
+static void DefaultExitFatal() { exit(1); }
+void (*ExitFatal)() = &DefaultExitFatal;
+
+}  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/logging.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/logging.h
new file mode 100644
index 0000000..4b7dff6
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/logging.h
@@ -0,0 +1,66 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OPEN_VCDIFF_LOGGING_H_
+#define OPEN_VCDIFF_LOGGING_H_
+
+#include <config.h>
+#include <iostream>
+#include <vector>
+
+// Windows API defines ERROR
+#ifdef ERROR
+#undef ERROR
+#endif  // ERROR
+
+namespace open_vcdiff {
+
+enum LogLevel {
+  INFO,
+  WARNING,
+  ERROR,
+  FATAL
+};
+
+#ifndef NDEBUG
+#define DFATAL FATAL
+#else  // NDEBUG
+#define DFATAL ERROR
+#endif  // !NDEBUG
+
+extern bool g_fatal_error_occurred;
+extern void (*ExitFatal)();
+
+inline std::ostream& LogMessage(LogLevel level, const char* level_name) {
+  if (level == FATAL) {
+    g_fatal_error_occurred = true;
+  }
+  return std::cerr << level_name << ": ";
+}
+
+inline void CheckFatalError() {
+  if (g_fatal_error_occurred) {
+    g_fatal_error_occurred = false;
+    (*ExitFatal)();
+  }
+}
+
+}  // namespace open_vcdiff
+
+#define LOG(level)   LogMessage(open_vcdiff::level, #level)
+#define LOG_ENDL     std::endl; \
+                     open_vcdiff::CheckFatalError();
+
+#endif  // OPEN_VCDIFF_LOGGING_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/output_string_crope.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/output_string_crope.h
new file mode 100644
index 0000000..555f407
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/output_string_crope.h
@@ -0,0 +1,40 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Contains a class that demonstrates how to specialize OutputString for the
+// crope type, so that cropes can be passed as output arguments to the encoder
+// and decoder.
+
+#ifndef OPEN_VCDIFF_OUTPUT_STRING_CROPE_H_
+#define OPEN_VCDIFF_OUTPUT_STRING_CROPE_H_
+#include <config.h>
+#ifdef HAVE_EXT_ROPE
+#include <ext/rope>
+#include "google/output_string.h"
+
+namespace open_vcdiff {
+
+// *** OutputString interface for crope (OutputCrope)
+
+// crope::reserve(), if defined, does nothing
+template <>
+void OutputString<__gnu_cxx::crope>::ReserveAdditionalBytes(
+    size_t /*res_arg*/) { }
+
+typedef OutputString<__gnu_cxx::crope> OutputCrope;
+
+}  // namespace open_vcdiff
+#endif  // HAVE_EXT_ROPE
+#endif  // OPEN_VCDIFF_OUTPUT_STRING_CROPE_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/output_string_test.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/output_string_test.cc
new file mode 100644
index 0000000..86df075
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/output_string_test.cc
@@ -0,0 +1,117 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <config.h>
+#include <string>
+#include "google/output_string.h"
+#include "testing.h"
+
+#ifdef HAVE_EXT_ROPE
+#include <ext/rope>
+#include "output_string_crope.h"
+#endif  // HAVE_EXT_ROPE
+
+namespace open_vcdiff {
+
+namespace {
+
+using std::string;
+#ifdef HAVE_EXT_ROPE
+using __gnu_cxx::crope;
+#endif  // HAVE_EXT_ROPE
+
+class OutputStringTest : public testing::Test {
+ public:
+  OutputStringTest() : string_("ab"), output_string_(&string_) { }
+
+  virtual ~OutputStringTest() { }
+
+ protected:
+  string string_;
+  OutputString<string> output_string_;
+};
+
+TEST_F(OutputStringTest, Append) {
+  output_string_.append("cdef", 2);
+  EXPECT_EQ("abcd", string_);
+}
+
+TEST_F(OutputStringTest, Clear) {
+  output_string_.clear();
+  EXPECT_EQ("", string_);
+}
+
+TEST_F(OutputStringTest, PushBack) {
+  output_string_.push_back('c');
+  EXPECT_EQ("abc", string_);
+}
+
+TEST_F(OutputStringTest, Reserve) {
+  const size_t initial_capacity = string_.capacity();
+  string_.resize(string_.capacity());
+  EXPECT_EQ(initial_capacity, string_.capacity());
+  output_string_.ReserveAdditionalBytes(1);
+  EXPECT_LE(initial_capacity + 1, string_.capacity());
+}
+
+TEST_F(OutputStringTest, Size) {
+  EXPECT_EQ(string_.size(), output_string_.size());
+  string_.push_back('c');
+  EXPECT_EQ(string_.size(), output_string_.size());
+  string_.clear();
+  EXPECT_EQ(string_.size(), output_string_.size());
+}
+
+#ifdef HAVE_EXT_ROPE
+class OutputCRopeTest : public testing::Test {
+ public:
+  OutputCRopeTest() : crope_("ab"), output_crope_(&crope_) { }
+
+  virtual ~OutputCRopeTest() { }
+
+ protected:
+  crope crope_;
+  OutputCrope output_crope_;
+};
+
+TEST_F(OutputCRopeTest, Append) {
+  output_crope_.append("cdef", 2);
+  crope expected_abcd("abcd");
+  EXPECT_EQ(expected_abcd, crope_);
+}
+
+TEST_F(OutputCRopeTest, Clear) {
+  output_crope_.clear();
+  crope expected_empty;
+  EXPECT_EQ(expected_empty, crope_);
+}
+
+TEST_F(OutputCRopeTest, PushBack) {
+  output_crope_.push_back('c');
+  crope expected_abc("abc");
+  EXPECT_EQ(expected_abc, crope_);
+}
+
+TEST_F(OutputCRopeTest, Size) {
+  EXPECT_EQ(crope_.size(), output_crope_.size());
+  crope_.push_back('c');
+  EXPECT_EQ(crope_.size(), output_crope_.size());
+  crope_.clear();
+  EXPECT_EQ(crope_.size(), output_crope_.size());
+}
+#endif  // HAVE_EXT_ROPE
+
+}  // anonymous namespace
+}  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/rolling_hash.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/rolling_hash.h
new file mode 100644
index 0000000..c757c83
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/rolling_hash.h
@@ -0,0 +1,237 @@
+// Copyright 2007, 2008 Google Inc.
+// Authors: Jeff Dean, Sanjay Ghemawat, Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OPEN_VCDIFF_ROLLING_HASH_H_
+#define OPEN_VCDIFF_ROLLING_HASH_H_
+
+#include <config.h>
+#include <stdint.h>  // uint32_t
+#include "logging.h"
+
+namespace open_vcdiff {
+
+// Rabin-Karp hasher module -- this is a faster version with different
+// constants, so it's not quite Rabin-Karp fingerprinting, but its behavior is
+// close enough for most applications.
+
+// Definitions common to all hash window sizes.
+class RollingHashUtil {
+ public:
+  // Multiplier for incremental hashing.  The compiler should be smart enough to
+  // convert (val * kMult) into ((val << 8) + val).
+  static const uint32_t kMult = 257;
+
+  // All hashes are returned modulo "kBase".  Current implementation requires
+  // kBase <= 2^32/kMult to avoid overflow.  Also, kBase must be a power of two
+  // so that we can compute modulus efficiently.
+  static const uint32_t kBase = (1 << 23);
+
+  // Returns operand % kBase, assuming that kBase is a power of two.
+  static inline uint32_t ModBase(uint32_t operand) {
+    return operand & (kBase - 1);
+  }
+
+  // Given an unsigned integer "operand", returns an unsigned integer "result"
+  // such that
+  //     result < kBase
+  // and
+  //     ModBase(operand + result) == 0
+  static inline uint32_t FindModBaseInverse(uint32_t operand) {
+    // The subtraction (0 - operand) produces an unsigned underflow for any
+    // operand except 0.  The underflow results in a (very large) unsigned
+    // number.  Binary subtraction is used instead of unary negation because
+    // some compilers (e.g. Visual Studio 7+) produce a warning if an unsigned
+    // value is negated.
+    //
+    // The C++ mod operation (operand % kBase) may produce different results for
+    // different compilers if operand is negative.  That is not a problem in
+    // this case, since all numbers used are unsigned, and ModBase does its work
+    // using bitwise arithmetic rather than the % operator.
+    return ModBase(uint32_t(0) - operand);
+  }
+
+  // Here's the heart of the hash algorithm.  Start with a partial_hash value of
+  // 0, and run this HashStep once against each byte in the data window to be
+  // hashed.  The result will be the hash value for the entire data window.  The
+  // Hash() function, below, does exactly this, albeit with some refinements.
+  static inline uint32_t HashStep(uint32_t partial_hash,
+                                  unsigned char next_byte) {
+    return ModBase((partial_hash * kMult) + next_byte);
+  }
+
+  // Use this function to start computing a new hash value based on the first
+  // two bytes in the window.  It is equivalent to calling
+  //     HashStep(HashStep(0, ptr[0]), ptr[1])
+  // but takes advantage of the fact that the maximum value of
+  // (ptr[0] * kMult) + ptr[1] is not large enough to exceed kBase, thus
+  // avoiding an unnecessary ModBase operation.
+  static inline uint32_t HashFirstTwoBytes(const char* ptr) {
+    return (static_cast<unsigned char>(ptr[0]) * kMult)
+        + static_cast<unsigned char>(ptr[1]);
+  }
+ private:
+  // Making these private avoids copy constructor and assignment operator.
+  // No objects of this type should be constructed.
+  RollingHashUtil();
+  RollingHashUtil(const RollingHashUtil&);  // NOLINT
+  void operator=(const RollingHashUtil&);
+};
+
+// window_size must be >= 2.
+template<int window_size>
+class RollingHash {
+ public:
+  // Perform global initialization that is required in order to instantiate a
+  // RollingHash.  This function *must* be called (preferably on startup) by any
+  // program that uses a RollingHash.  It is harmless to call this function more
+  // than once.  It is not thread-safe, but calling it from two different
+  // threads at the same time can only cause a memory leak, not incorrect
+  // behavior.  Make sure to call it before spawning any threads that could use
+  // RollingHash.  The function returns true if initialization succeeds, or
+  // false if initialization fails, in which case the caller should not proceed
+  // to construct any objects of type RollingHash.
+  static bool Init();
+
+  // Initialize hasher to maintain a window of the specified size.  You need an
+  // instance of this type to use UpdateHash(), but Hash() does not depend on
+  // remove_table_, so it is static.
+  RollingHash() {
+    if (!remove_table_) {
+      LOG(DFATAL) << "RollingHash object instantiated"
+                     " before calling RollingHash::Init()" << LOG_ENDL;
+    }
+  }
+
+  // Compute a hash of the window "ptr[0, window_size - 1]".
+  static uint32_t Hash(const char* ptr) {
+    uint32_t h = RollingHashUtil::HashFirstTwoBytes(ptr);
+    for (int i = 2; i < window_size; ++i) {
+      h = RollingHashUtil::HashStep(h, ptr[i]);
+    }
+    return h;
+  }
+
+  // Update a hash by removing the oldest byte and adding a new byte.
+  //
+  // UpdateHash takes the hash value of buffer[0] ... buffer[window_size -1]
+  // along with the value of buffer[0] (the "old_first_byte" argument)
+  // and the value of buffer[window_size] (the "new_last_byte" argument).
+  // It quickly computes the hash value of buffer[1] ... buffer[window_size]
+  // without having to run Hash() on the entire window.
+  //
+  // The larger the window, the more advantage comes from using UpdateHash()
+  // (which runs in time independent of window_size) instead of Hash().
+  // Each time window_size doubles, the time to execute Hash() also doubles,
+  // while the time to execute UpdateHash() remains constant.  Empirical tests
+  // have borne out this statement.
+  uint32_t UpdateHash(uint32_t old_hash,
+                      const char old_first_byte,
+                      const char new_last_byte) const {
+    uint32_t partial_hash = RemoveFirstByteFromHash(old_hash, old_first_byte);
+    return RollingHashUtil::HashStep(partial_hash, new_last_byte);
+  }
+
+ protected:
+  // Given a full hash value for buffer[0] ... buffer[window_size -1], plus the
+  // value of the first byte buffer[0], this function returns a *partial* hash
+  // value for buffer[1] ... buffer[window_size -1].  See the comments in
+  // Init(), below, for a description of how the contents of remove_table_ are
+  // computed.
+  static uint32_t RemoveFirstByteFromHash(uint32_t full_hash,
+                                          unsigned char first_byte) {
+    return RollingHashUtil::ModBase(full_hash + remove_table_[first_byte]);
+  }
+
+ private:
+  // We keep a table that maps from any byte "b" to
+  //    (- b * pow(kMult, window_size - 1)) % kBase
+  static const uint32_t* remove_table_;
+};
+
+// For each window_size, fill a 256-entry table such that
+//        the hash value of buffer[0] ... buffer[window_size - 1]
+//      + remove_table_[buffer[0]]
+//     == the hash value of buffer[1] ... buffer[window_size - 1]
+// See the comments in Init(), below, for a description of how the contents of
+// remove_table_ are computed.
+template<int window_size>
+const uint32_t* RollingHash<window_size>::remove_table_ = NULL;
+
+// Init() checks to make sure that the static object remove_table_ has been
+// initialized; if not, it does the considerable work of populating it.  Once
+// it's ready, the table can be used for any number of RollingHash objects of
+// the same window_size.
+//
+template<int window_size>
+bool RollingHash<window_size>::Init() {
+  if (window_size < 2) {
+    LOG(ERROR) << "RollingHash window size " << window_size
+               << " is too small" << LOG_ENDL;
+    return false;
+  }
+  if (remove_table_ == NULL) {
+    // The new object is placed into a local pointer instead of directly into
+    // remove_table_, for two reasons:
+    //   1. remove_table_ is a pointer to const.  The table is populated using
+    //      the non-const local pointer and then assigned to the global const
+    //      pointer once it's ready.
+    //   2. No other thread will ever see remove_table_ pointing to a
+    //      partially-initialized table.  If two threads happen to call Init()
+    //      at the same time, two tables with the same contents may be created
+    //      (causing a memory leak), but the results will be consistent
+    //      no matter which of the two tables is used.
+    uint32_t* new_remove_table = new uint32_t[256];
+    // Compute multiplier.  Concisely, it is:
+    //     pow(kMult, (window_size - 1)) % kBase,
+    // but we compute the power in integer form.
+    uint32_t multiplier = 1;
+    for (int i = 0; i < window_size - 1; ++i) {
+      multiplier =
+          RollingHashUtil::ModBase(multiplier * RollingHashUtil::kMult);
+    }
+    // For each character removed_byte, compute
+    //     remove_table_[removed_byte] ==
+    //         (- (removed_byte * pow(kMult, (window_size - 1)))) % kBase
+    // where the power operator "pow" is taken in integer form.
+    //
+    // If you take a hash value fp representing the hash of
+    //     buffer[0] ... buffer[window_size - 1]
+    // and add the value of remove_table_[buffer[0]] to it, the result will be
+    // a partial hash value for
+    //     buffer[1] ... buffer[window_size - 1]
+    // that is to say, it no longer includes buffer[0].
+    //
+    // The following byte at buffer[window_size] can then be merged with this
+    // partial hash value to arrive quickly at the hash value for a window that
+    // has advanced by one byte, to
+    //     buffer[1] ... buffer[window_size]
+    // In fact, that is precisely what happens in UpdateHash, above.
+    uint32_t byte_times_multiplier = 0;
+    for (int removed_byte = 0; removed_byte < 256; ++removed_byte) {
+      new_remove_table[removed_byte] =
+          RollingHashUtil::FindModBaseInverse(byte_times_multiplier);
+      // Iteratively adding the multiplier in this loop is equivalent to
+      // computing (removed_byte * multiplier), and is faster
+      byte_times_multiplier =
+          RollingHashUtil::ModBase(byte_times_multiplier + multiplier);
+    }
+    remove_table_ = new_remove_table;
+  }
+  return true;
+}
+
+}  // namespace open_vcdiff
+
+#endif  // OPEN_VCDIFF_ROLLING_HASH_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/rolling_hash_test.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/rolling_hash_test.cc
new file mode 100644
index 0000000..1a7da9a
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/rolling_hash_test.cc
@@ -0,0 +1,231 @@
+// Copyright 2007 Google Inc.
+// Authors: Jeff Dean, Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <config.h>
+#include "rolling_hash.h"
+#include <stdint.h>  // uint32_t
+#include <cstdlib>  // rand, srand
+#include <vector>
+#include "testing.h"
+
+namespace open_vcdiff {
+namespace {
+
+static const uint32_t kBase = RollingHashUtil::kBase;
+
+class RollingHashSimpleTest : public testing::Test {
+ protected:
+  RollingHashSimpleTest() { }
+  virtual ~RollingHashSimpleTest() { }
+
+  void TestModBase(uint32_t operand) {
+    EXPECT_EQ(operand % kBase, RollingHashUtil::ModBase(operand));
+    EXPECT_EQ(static_cast<uint32_t>((-static_cast<int32_t>(operand)) % kBase),
+              RollingHashUtil::FindModBaseInverse(operand));
+    EXPECT_EQ(0U, RollingHashUtil::ModBase(
+        operand + RollingHashUtil::FindModBaseInverse(operand)));
+  }
+
+  void TestHashFirstTwoBytes(char first_value, char second_value) {
+    char buf[2];
+    buf[0] = first_value;
+    buf[1] = second_value;
+    EXPECT_EQ(RollingHashUtil::HashFirstTwoBytes(buf),
+              RollingHashUtil::HashStep(RollingHashUtil::HashStep(0,
+                                                                  first_value),
+                                        second_value));
+    EXPECT_EQ(RollingHashUtil::HashFirstTwoBytes(buf),
+              RollingHashUtil::HashStep(static_cast<unsigned char>(first_value),
+                                        second_value));
+  }
+};
+
+#ifdef GTEST_HAS_DEATH_TEST
+typedef RollingHashSimpleTest RollingHashDeathTest;
+#endif  // GTEST_HAS_DEATH_TEST
+
+TEST_F(RollingHashSimpleTest, KBaseIsAPowerOfTwo) {
+  EXPECT_EQ(0U, kBase & (kBase - 1));
+}
+
+TEST_F(RollingHashSimpleTest, TestModBaseForValues) {
+  TestModBase(0);
+  TestModBase(10);
+  TestModBase(static_cast<uint32_t>(-10));
+  TestModBase(kBase - 1);
+  TestModBase(kBase);
+  TestModBase(kBase + 1);
+  TestModBase(0x7FFFFFFF);
+  TestModBase(0x80000000);
+  TestModBase(0xFFFFFFFE);
+  TestModBase(0xFFFFFFFF);
+}
+
+TEST_F(RollingHashSimpleTest, VerifyHashFirstTwoBytes) {
+  TestHashFirstTwoBytes(0x00, 0x00);
+  TestHashFirstTwoBytes(0x00, 0xFF);
+  TestHashFirstTwoBytes(0xFF, 0x00);
+  TestHashFirstTwoBytes(0xFF, 0xFF);
+  TestHashFirstTwoBytes(0x00, 0x80);
+  TestHashFirstTwoBytes(0x7F, 0xFF);
+  TestHashFirstTwoBytes(0x7F, 0x80);
+  TestHashFirstTwoBytes(0x01, 0x8F);
+}
+
+#ifdef GTEST_HAS_DEATH_TEST
+TEST_F(RollingHashDeathTest, InstantiateBlockHashWithoutCallingInit) {
+  EXPECT_DEBUG_DEATH(RollingHash<16> bad_hash, "Init");
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+class RollingHashTest : public testing::Test {
+ public:
+  static const int kUpdateHashBlocks = 1000;
+  static const int kLargestBlockSize = 128;
+
+  static void MakeRandomBuffer(char* buffer, int buffer_size) {
+    for (int i = 0; i < buffer_size; ++i) {
+      buffer[i] = PortableRandomInRange<unsigned char>(0xFF);
+    }
+  }
+
+  template<int kBlockSize> static void BM_DefaultHash(int iterations,
+                                                      const char *buffer) {
+    RollingHash<kBlockSize> hasher;
+    static uint32_t result_array[kUpdateHashBlocks];
+    for (int iter = 0; iter < iterations; ++iter) {
+      for (int i = 0; i < kUpdateHashBlocks; ++i) {
+        result_array[i] = hasher.Hash(&buffer[i]);
+      }
+    }
+  }
+
+  template<int kBlockSize> static void BM_UpdateHash(int iterations,
+                                                     const char *buffer) {
+    RollingHash<kBlockSize> hasher;
+    static uint32_t result_array[kUpdateHashBlocks];
+    for (int iter = 0; iter < iterations; ++iter) {
+      uint32_t running_hash = hasher.Hash(buffer);
+      for (int i = 0; i < kUpdateHashBlocks; ++i) {
+        running_hash = hasher.UpdateHash(running_hash,
+                                         buffer[i],
+                                         buffer[i + kBlockSize]);
+        result_array[i] = running_hash;
+      }
+    }
+  }
+
+ protected:
+  static const int kUpdateHashTestIterations = 400;
+  static const int kTimingTestSize = 1 << 14;  // 16K iterations
+
+  RollingHashTest() { }
+  virtual ~RollingHashTest() { }
+
+  template<int kBlockSize> void UpdateHashMatchesHashForBlockSize() {
+    RollingHash<kBlockSize>::Init();
+    RollingHash<kBlockSize> hasher;
+    for (int x = 0; x < kUpdateHashTestIterations; ++x) {
+      int random_buffer_size =
+          PortableRandomInRange(kUpdateHashBlocks - 1) + kBlockSize;
+      MakeRandomBuffer(buffer_, random_buffer_size);
+      uint32_t running_hash = hasher.Hash(buffer_);
+      for (int i = kBlockSize; i < random_buffer_size; ++i) {
+        // UpdateHash() calculates the hash value incrementally.
+        running_hash = hasher.UpdateHash(running_hash,
+                                         buffer_[i - kBlockSize],
+                                         buffer_[i]);
+        // Hash() calculates the hash value from scratch.  Verify that both
+        // methods return the same hash value.
+        EXPECT_EQ(running_hash, hasher.Hash(&buffer_[i + 1 - kBlockSize]));
+      }
+    }
+  }
+
+  template<int kBlockSize> double DefaultHashTimingTest() {
+    // Execution time is expected to be O(kBlockSize) per hash operation,
+    // so scale the number of iterations accordingly
+    const int kTimingTestIterations = kTimingTestSize / kBlockSize;
+    CycleTimer timer;
+    timer.Start();
+    BM_DefaultHash<kBlockSize>(kTimingTestIterations, buffer_);
+    timer.Stop();
+    return static_cast<double>(timer.GetInUsec())
+        / (kTimingTestIterations * kUpdateHashBlocks);
+  }
+
+  template<int kBlockSize> double RollingTimingTest() {
+    // Execution time is expected to be O(1) per hash operation,
+    // so leave the number of iterations constant
+    const int kTimingTestIterations = kTimingTestSize;
+    CycleTimer timer;
+    timer.Start();
+    BM_UpdateHash<kBlockSize>(kTimingTestIterations, buffer_);
+    timer.Stop();
+    return static_cast<double>(timer.GetInUsec())
+        / (kTimingTestIterations * kUpdateHashBlocks);
+  }
+
+  double FindPercentage(double original, double modified) {
+    if (original < 0.0001) {
+      return 0.0;
+    } else {
+      return ((modified - original) / original) * 100.0;
+    }
+  }
+
+  template<int kBlockSize> void RunTimingTestForBlockSize() {
+    RollingHash<kBlockSize>::Init();
+    MakeRandomBuffer(buffer_, sizeof(buffer_));
+    const double time_for_default_hash = DefaultHashTimingTest<kBlockSize>();
+    const double time_for_rolling_hash = RollingTimingTest<kBlockSize>();
+    printf("%d\t%f\t%f (%f%%)\n",
+           kBlockSize,
+           time_for_default_hash,
+           time_for_rolling_hash,
+           FindPercentage(time_for_default_hash, time_for_rolling_hash));
+    CHECK_GT(time_for_default_hash, 0.0);
+    CHECK_GT(time_for_rolling_hash, 0.0);
+    if (kBlockSize > 16) {
+      EXPECT_GT(time_for_default_hash, time_for_rolling_hash);
+    }
+  }
+
+  char buffer_[kUpdateHashBlocks + kLargestBlockSize];
+};
+
+TEST_F(RollingHashTest, UpdateHashMatchesHashFromScratch) {
+  srand(1);  // test should be deterministic, including calls to rand()
+  UpdateHashMatchesHashForBlockSize<4>();
+  UpdateHashMatchesHashForBlockSize<8>();
+  UpdateHashMatchesHashForBlockSize<16>();
+  UpdateHashMatchesHashForBlockSize<32>();
+  UpdateHashMatchesHashForBlockSize<64>();
+  UpdateHashMatchesHashForBlockSize<128>();
+}
+
+TEST_F(RollingHashTest, TimingTests) {
+  srand(1);  // test should be deterministic, including calls to rand()
+  printf("BlkSize\tHash (us)\tUpdateHash (us)\n");
+  RunTimingTestForBlockSize<4>();
+  RunTimingTestForBlockSize<8>();
+  RunTimingTestForBlockSize<16>();
+  RunTimingTestForBlockSize<32>();
+  RunTimingTestForBlockSize<64>();
+  RunTimingTestForBlockSize<128>();
+}
+
+}  // anonymous namespace
+}  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/testing.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/testing.h
new file mode 100644
index 0000000..205871b
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/testing.h
@@ -0,0 +1,180 @@
+// Copyright 2008 Google Inc.
+// Authors: Craig Silverstein, Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OPEN_VCDIFF_TESTING_H_
+#define OPEN_VCDIFF_TESTING_H_
+
+#include <config.h>
+#include <stdint.h>  // int64_t, uint64_t
+#include <time.h>  // gettimeofday
+#include <cassert>
+#include <cstdlib>  // rand
+#include "gtest/gtest.h"
+
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>  // struct timeval
+#endif  // HAVE_SYS_TIME_H
+
+#ifdef HAVE_WINDOWS_H
+#include <windows.h>  // QueryPerformanceCounter
+#endif  // HAVE_WINDOWS_H
+
+// CHECK is used for assertions that verify the consistency of the test itself,
+// rather than correctness of the code that is being tested.
+//
+// It is better to use a preprocessor macro for CHECK
+// than an inline function, because assert() may report
+// the source file and line where the failure occurred.
+//
+// Putting parentheses around the macro arguments
+// (e.g. "assert((X) == (Y))") would be good practice
+// but would produce error messages that are inconsistent
+// with those expected in the unit tests.
+
+#define CHECK(CONDITION) assert(CONDITION)
+#define CHECK_EQ(X, Y) assert(X == Y)
+#define CHECK_NE(X, Y) assert(X != Y)
+#define CHECK_GE(X, Y) assert(X >= Y)
+#define CHECK_GT(X, Y) assert(X > Y)
+#define CHECK_LE(X, Y) assert(X <= Y)
+#define CHECK_LT(X, Y) assert(X < Y)
+
+namespace open_vcdiff {
+
+// Support for timing tests
+#if defined(HAVE_GETTIMEOFDAY)
+class CycleTimer {
+ public:
+  inline CycleTimer() {
+    Reset();
+  }
+
+  inline void Reset() {
+    start_time_.tv_sec = 0;
+    start_time_.tv_usec = 0;
+    cumulative_time_in_usec_ = 0;
+  }
+
+  inline void Start() {
+    CHECK(!IsStarted());
+    gettimeofday(&start_time_, NULL);
+  }
+
+  inline void Restart() {
+    Reset();
+    Start();
+  }
+
+  inline void Stop() {
+    struct timeval end_time;
+    gettimeofday(&end_time, NULL);
+    CHECK(IsStarted());
+    cumulative_time_in_usec_ +=
+        (1000000 * (end_time.tv_sec - start_time_.tv_sec))
+        + end_time.tv_usec - start_time_.tv_usec;
+    start_time_.tv_sec = 0;
+    start_time_.tv_usec = 0;
+  }
+
+  inline int64_t GetInUsec() {
+    return cumulative_time_in_usec_;
+  }
+
+ private:
+  inline bool IsStarted() {
+    return (start_time_.tv_usec > 0) || (start_time_.tv_sec > 0);
+  }
+
+  struct timeval start_time_;
+  int64_t cumulative_time_in_usec_;
+};
+#elif defined(HAVE_QUERYPERFORMANCECOUNTER)
+class CycleTimer {
+ public:
+  inline CycleTimer() {
+    LARGE_INTEGER frequency;
+    QueryPerformanceFrequency(&frequency);  // counts per second
+    usecs_per_count_ = 1000000.0 / static_cast<double>(frequency.QuadPart);
+    Reset();
+  }
+
+  inline void Reset() {
+    start_time_.QuadPart = 0;
+    cumulative_time_in_usec_ = 0;
+  }
+
+  inline void Start() {
+    CHECK(!IsStarted());
+    QueryPerformanceCounter(&start_time_);
+  }
+
+  inline void Restart() {
+    Reset();
+    Start();
+  }
+
+  inline void Stop() {
+    LARGE_INTEGER end_time;
+    QueryPerformanceCounter(&end_time);
+    CHECK(IsStarted());
+    double count_diff = static_cast<double>(
+        end_time.QuadPart - start_time_.QuadPart);
+    cumulative_time_in_usec_ +=
+        static_cast<int64_t>(count_diff * usecs_per_count_);
+    start_time_.QuadPart = 0;
+  }
+
+  inline int64_t GetInUsec() {
+    return cumulative_time_in_usec_;
+  }
+
+ private:
+  inline bool IsStarted() {
+    return start_time_.QuadPart > 0;
+  }
+
+  LARGE_INTEGER start_time_;
+  int64_t cumulative_time_in_usec_;
+  double usecs_per_count_;
+};
+#else
+#error CycleTimer needs an implementation that does not use gettimeofday or QueryPerformanceCounter
+#endif  // HAVE_GETTIMEOFDAY
+
+// This function returns a pseudo-random value of type IntType between 0 and
+// limit.  It uses the standard rand() function to produce the value, and makes
+// as many calls to rand() as needed to ensure that the values returned can fall
+// within the full range specified.  It is slow, so don't include calls to this
+// function when calculating the execution time of tests.
+//
+template<typename IntType>
+inline IntType PortableRandomInRange(IntType limit) {
+  uint64_t value = rand();
+  double rand_limit = RAND_MAX;  // The maximum possible value
+  while (rand_limit < limit) {
+    // value is multiplied by (RAND_MAX + 1) each iteration. This factor will be
+    // canceled out when we divide by rand_limit to get scaled_value, below.
+    value = (value * (static_cast<uint64_t>(RAND_MAX) + 1)) + rand();
+    rand_limit = (rand_limit * (RAND_MAX + 1.0)) + RAND_MAX;
+  }
+  // Translate the random 64-bit integer into a floating-point value between
+  // 0.0 (inclusive) and 1.0 (inclusive).
+  const double scaled_value = value / rand_limit;
+  return static_cast<IntType>(limit * scaled_value);
+}
+
+}  // namespace open_vcdiff
+
+#endif  // OPEN_VCDIFF_TESTING_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/varint_bigendian.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/varint_bigendian.cc
new file mode 100644
index 0000000..4dbf7bb
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/varint_bigendian.cc
@@ -0,0 +1,187 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <config.h>
+#include "varint_bigendian.h"
+#include <stdint.h>  // int32_t, int64_t
+#include <string>
+#include "logging.h"
+#include "google/output_string.h"
+
+namespace open_vcdiff {
+
+using std::string;
+
+template<> const int32_t VarintBE<int32_t>::kMaxVal = 0x7FFFFFFF;
+template<> const int64_t VarintBE<int64_t>::kMaxVal = 0x7FFFFFFFFFFFFFFFULL;
+
+// Check whether the variable-length integer runs off the end
+// of the available input.  If there are few bytes left in the input,
+// then AND together their most significant bits (the continuation bits)
+// and see if they are all set; if so, the integer runs off the end of the
+// available input.  Only kMaxBytes - 1 bytes need be checked; if there are
+// kMaxBytes bytes with their continuation bits set, it is an error condition
+// and it will be caught later.
+//
+// The function is specific to a particular integer type (number of bits.)
+//
+template <>
+inline bool VarintBE<int32_t>::ReachedEndOfData(const char* parse_ptr,
+                                                const char* limit) {
+  unsigned char reached_end_of_data_flag = 0x80;
+  const unsigned char* const bitwise_ptr =
+    reinterpret_cast<const unsigned char*>(parse_ptr);
+  switch (limit - parse_ptr) {
+    case 4: reached_end_of_data_flag &= bitwise_ptr[3];
+            // fall through
+    case 3: reached_end_of_data_flag &= bitwise_ptr[2];
+            // fall through
+    case 2: reached_end_of_data_flag &= bitwise_ptr[1];
+            // fall through
+    case 1: reached_end_of_data_flag &= bitwise_ptr[0];
+            return (reached_end_of_data_flag == 0x80);
+    case 0: return true;
+  }
+  return false;
+}
+
+template <>
+inline bool VarintBE<int64_t>::ReachedEndOfData(const char* parse_ptr,
+                                                const char* limit) {
+  unsigned char reached_end_of_data_flag = 0x80;
+  const unsigned char* const bitwise_ptr =
+    reinterpret_cast<const unsigned char*>(parse_ptr);
+  switch (limit - parse_ptr) {
+    case 8: reached_end_of_data_flag &= bitwise_ptr[7];
+            // fall through
+    case 7: reached_end_of_data_flag &= bitwise_ptr[6];
+            // fall through
+    case 6: reached_end_of_data_flag &= bitwise_ptr[5];
+            // fall through
+    case 5: reached_end_of_data_flag &= bitwise_ptr[4];
+            // fall through
+    case 4: reached_end_of_data_flag &= bitwise_ptr[3];
+            // fall through
+    case 3: reached_end_of_data_flag &= bitwise_ptr[2];
+            // fall through
+    case 2: reached_end_of_data_flag &= bitwise_ptr[1];
+            // fall through
+    case 1: reached_end_of_data_flag &= bitwise_ptr[0];
+            return (reached_end_of_data_flag == 0x80);
+    case 0: return true;
+  }
+  return false;
+}
+
+// Reads a variable-length integer from **varint_ptr
+// and returns it in a fixed-length representation.  Increments
+// *varint_ptr by the number of bytes read.  Will only read
+// a maximum of kMaxBytes bytes from **varint_ptr even if the input data
+// has the continuation bit set for more bytes.  Will not read
+// past limit.  Returns RESULT_ERROR if the value parsed
+// does not fit in a non-negative signed integer.
+// Returns RESULT_END_OF_DATA if address_stream_end is reached
+// before the whole integer can be decoded.
+//
+template <typename SignedIntegerType>
+SignedIntegerType VarintBE<SignedIntegerType>::Parse(const char* limit,
+                                                     const char** varint_ptr) {
+  const char* parse_ptr = *varint_ptr;
+  if (ReachedEndOfData(parse_ptr, limit)) {
+    return RESULT_END_OF_DATA;
+  }
+  SignedIntegerType result = *parse_ptr & 0x7F;
+  while (*parse_ptr & 0x80) {
+    if (result > (kMaxVal >> 7)) {
+      // Shifting result by 7 bits would produce a number too large
+      // to be stored in a non-negative SignedIntegerType (an overflow.)
+      return RESULT_ERROR;
+    }
+    ++parse_ptr;
+    result = (result << 7) + (*parse_ptr & 0x7F);
+  }
+  *varint_ptr = parse_ptr + 1;
+  return result;
+}
+
+template <typename SignedIntegerType>
+int VarintBE<SignedIntegerType>::EncodeInternal(SignedIntegerType v,
+                                                char* varint_buf) {
+  if (v < 0) {
+    LOG(DFATAL) << "Negative value " << v
+                << " passed to VarintBE::EncodeInternal,"
+                   " which requires non-negative argument" << LOG_ENDL;
+    return 0;
+  }
+  int length = 1;
+  char* buf_ptr = &varint_buf[kMaxBytes - 1];
+  *buf_ptr = static_cast<char>(v & 0x7F);
+  --buf_ptr;
+  v >>= 7;
+  while (v) {
+    *buf_ptr = static_cast<char>((v & 0x7F) | 0x80);  // add continuation bit
+    --buf_ptr;
+    ++length;
+    v >>= 7;
+  }
+  return length;
+}
+
+template <typename SignedIntegerType>
+int VarintBE<SignedIntegerType>::Encode(SignedIntegerType v, char* ptr) {
+  char varint_buf[kMaxBytes];
+  const int length = EncodeInternal(v, varint_buf);
+  memcpy(ptr, &varint_buf[kMaxBytes - length], length);
+  return length;
+}
+
+template <typename SignedIntegerType>
+void VarintBE<SignedIntegerType>::AppendToString(SignedIntegerType value,
+                                                 string* s) {
+  char varint_buf[kMaxBytes];
+  const int length = EncodeInternal(value, varint_buf);
+  s->append(&varint_buf[kMaxBytes - length], length);
+}
+
+template <typename SignedIntegerType>
+void VarintBE<SignedIntegerType>::AppendToOutputString(
+    SignedIntegerType value,
+    OutputStringInterface* output_string) {
+  char varint_buf[kMaxBytes];
+  const int length = EncodeInternal(value, varint_buf);
+  output_string->append(&varint_buf[kMaxBytes - length], length);
+}
+
+// Returns the encoding length of the specified value.
+template <typename SignedIntegerType>
+int VarintBE<SignedIntegerType>::Length(SignedIntegerType v) {
+  if (v < 0) {
+    LOG(DFATAL) << "Negative value " << v
+                << " passed to VarintBE::Length,"
+                   " which requires non-negative argument" << LOG_ENDL;
+    return 0;
+  }
+  int length = 0;
+  do {
+    v >>= 7;
+    ++length;
+  } while (v);
+  return length;
+}
+
+template class VarintBE<int32_t>;
+template class VarintBE<int64_t>;
+
+}  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/varint_bigendian.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/varint_bigendian.h
new file mode 100644
index 0000000..34e5035
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/varint_bigendian.h
@@ -0,0 +1,140 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OPEN_VCDIFF_VARINT_BIGENDIAN_H_
+#define OPEN_VCDIFF_VARINT_BIGENDIAN_H_
+
+// Functions for manipulating variable-length integers as described in
+// RFC 3284, section 2.  (See http://www.ietf.org/rfc/rfc3284.txt)
+// This is the same format used by the Sfio library
+// and by the public-domain Sqlite package.
+//
+// The implementation found in this file contains buffer bounds checks
+// (not available in sqlite) and its goal is to improve speed
+// by using as few test-and-branch instructions as possible.
+//
+// The Sqlite format has the refinement that, if a 64-bit value is expected,
+// the ninth byte of the varint does not have a continuation bit, but instead
+// encodes 8 bits of information.  This allows 64 bits to be encoded compactly
+// in nine bytes.  However, that refinement does not appear in the format
+// description in RFC 3284, and so it is not used here.  In any case,
+// this header file deals only with *signed* integer types, and so a
+// "64-bit" integer is allowed to have only 63 significant bits; an additional
+// 64th bit would indicate a negative value and therefore an error.
+//
+
+#include <config.h>
+#include <stdint.h>  // int32_t, int64_t
+#include <string>
+#include "vcdiff_defs.h"  // RESULT_ERROR
+
+namespace open_vcdiff {
+
+using std::string;
+
+class OutputStringInterface;
+
+// This helper class is needed in order to ensure that
+// VarintBE<SignedIntegerType>::kMaxBytes is treated
+// as a compile-time constant when it is used as the size
+// of a static array.
+template <typename SignedIntegerType> class VarintMaxBytes;
+
+// 31 bits of data / 7 bits per byte <= 5 bytes
+template<> class VarintMaxBytes<int32_t> {
+ public:
+  static const int kMaxBytes = 5;
+};
+
+// 63 bits of data / 7 bits per byte == 9 bytes
+template<> class VarintMaxBytes<int64_t> {
+ public:
+  static const int kMaxBytes = 9;
+};
+
+// Objects of type VarintBE should not be instantiated.  The class is a
+// container for big-endian constant values and functions used to parse
+// and write a particular signed integer type.
+// Example: to parse a 32-bit integer value stored as a big-endian varint, use
+//     int32_t value = VarintBE<int32_t>::Parse(&ptr, limit);
+// Only 32-bit and 64-bit signed integers (int32_t and int64_t) are supported.
+// Using a different type as the template argument will likely result
+// in a link-time error for an undefined Parse() or Append() function.
+//
+template <typename SignedIntegerType>
+class VarintBE {  // BE stands for Big-Endian
+ public:
+  // The maximum positive value represented by a SignedIntegerType.
+  static const SignedIntegerType kMaxVal;
+
+  // Returns the maximum number of bytes needed to store a varint
+  // representation of a <SignedIntegerType> value.
+  static const int kMaxBytes = VarintMaxBytes<SignedIntegerType>::kMaxBytes;
+
+  // Attempts to parse a big-endian varint from a prefix of the bytes
+  // in [ptr,limit-1] and convert it into a signed, non-negative 32-bit
+  // integer.  Never reads a character at or beyond limit, and never reads
+  // a character at or beyond (*ptr + kMaxBytes).
+  // If a parsed varint would exceed the maximum value of
+  // a <SignedIntegerType>, returns RESULT_ERROR and does not modify *ptr.
+  // If parsing a varint at *ptr (without exceeding the capacity of
+  // a <SignedIntegerType>) would require reading past limit,
+  // returns RESULT_END_OF_DATA and does not modify *ptr.
+  // If limit == NULL, or limit < *ptr, no error will be signalled, but it is
+  // recommended that a limit always be supplied for security reasons.
+  static SignedIntegerType Parse(const char* limit, const char** ptr);
+
+  // Returns the encoding length of the specified value.
+  static int Length(SignedIntegerType v);
+
+  // Encodes "v" into "ptr" (which points to a buffer of length sufficient
+  // to hold "v")and returns the length of the encoding.
+  // The value of v must not be negative.
+  static int Encode(SignedIntegerType v, char* ptr);
+
+  // Appends the varint representation of "value" to "*s".
+  // The value of v must not be negative.
+  static void AppendToString(SignedIntegerType value, string* s);
+
+  // Appends the varint representation of "value" to output_string.
+  // The value of v must not be negative.
+  static void AppendToOutputString(SignedIntegerType value,
+                                   OutputStringInterface* output_string);
+
+ private:
+  // Encodes "v" into the LAST few bytes of varint_buf (which is a char array
+  // of size kMaxBytes) and returns the length of the encoding.
+  // The result will be stored in buf[(kMaxBytes - length) : (kMaxBytes - 1)],
+  // rather than in buf[0 : length].
+  // The value of v must not be negative.
+  static int EncodeInternal(SignedIntegerType v, char* varint_buf);
+
+  // Returns true if bytes_left <= kMaxBytes AND the next bytes_left bytes
+  // starting at parse_ptr all have their continuation bit (most significant
+  // bit) set.  This means that there may or may not be a valid encoded
+  // varint at parse_ptr, but it cannot be read or validated until more
+  // input is available.
+  static inline bool ReachedEndOfData(const char* parse_ptr,
+                                      const char* limit);
+
+  // These are private to avoid constructing any objects of this type
+  VarintBE();
+  VarintBE(const VarintBE&);  // NOLINT
+  void operator=(const VarintBE&);
+};
+
+}  // namespace open_vcdiff
+
+#endif  // OPEN_VCDIFF_VARINT_BIGENDIAN_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/varint_bigendian_test.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/varint_bigendian_test.cc
new file mode 100644
index 0000000..83e180e
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/varint_bigendian_test.cc
@@ -0,0 +1,322 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <config.h>
+#include "varint_bigendian.h"
+#include <cstdlib>  // rand, srand
+#include <string>
+#include <vector>
+#include "logging.h"
+#include "testing.h"
+
+namespace open_vcdiff {
+namespace {
+
+using std::string;
+
+class VarintBETestCommon : public testing::Test {
+ protected:
+  VarintBETestCommon()
+      : varint_buf_(VarintBE<int64_t>::kMaxBytes),
+        verify_encoded_byte_index_(0),
+        verify_expected_length_(0),
+        parse_data_ptr_(parse_data_all_FFs) {
+  }
+
+  virtual ~VarintBETestCommon() { }
+
+  void ExpectEncodedByte(char expected_byte) {
+    EXPECT_EQ(expected_byte, varint_buf_[verify_encoded_byte_index_]);
+    EXPECT_EQ(expected_byte, s_[verify_encoded_byte_index_]);
+    ++verify_encoded_byte_index_;
+  }
+
+  static const char parse_data_all_FFs[];
+  static const char parse_data_CADA1[];
+
+  std::vector<char> varint_buf_;
+  string s_;
+  int verify_encoded_byte_index_;
+  int verify_expected_length_;
+  const char* parse_data_ptr_;
+};
+
+template <typename SignedIntegerType>
+class VarintBETestTemplate : public VarintBETestCommon {
+ protected:
+  VarintBETestTemplate() { }
+
+  virtual ~VarintBETestTemplate() { }
+
+  typedef SignedIntegerType SignedIntType;
+  typedef VarintBE<SignedIntegerType> VarintType;
+
+  void StartEncodingTest(SignedIntegerType v, int expected_length) {
+    verify_expected_length_ = expected_length;
+    EXPECT_EQ(expected_length, VarintType::Length(v));
+    EXPECT_EQ(expected_length, VarintType::Encode(v, &varint_buf_[0]));
+    VarintType::AppendToString(v, &s_);
+    EXPECT_EQ(static_cast<size_t>(expected_length), s_.length());
+  }
+
+  void TestEncodeInvalid(SignedIntegerType v) {
+    EXPECT_DEATH(VarintType::Length(v), "v >= 0");
+    EXPECT_DEATH(VarintType::Encode(v, &varint_buf_[0]), "v >= 0");
+    EXPECT_DEATH(VarintType::AppendToString(v, &s_), ">= 0");
+  }
+
+  // Need one function for each test type that will be applied to
+  // multiple classes
+  void TemplateTestDISABLED_EncodeNegative();
+  void TemplateTestEncodeZero();
+  void TemplateTestEncodeEightBits();
+  void TemplateTestEncodeCADAD1A();
+  void TemplateTestEncode32BitMaxInt();
+  void TemplateTestEncodeDoesNotOverwriteExistingString();
+  void TemplateTestParseNullPointer();
+  void TemplateTestEndPointerPrecedesBeginning();
+  void TemplateTestParseVarintTooLong();
+  void TemplateTestParseIncompleteVarint();
+  void TemplateTestParseZero();
+  void TemplateTestParseCADA1();
+  void TemplateTestParseEmpty();
+  void TemplateTestParse123456789();
+  void TemplateTestDecode31Bits();
+  void TemplateTestEncodeDecodeRandom();
+};
+
+typedef VarintBETestTemplate<int32_t> VarintBEInt32Test;
+typedef VarintBETestTemplate<int64_t> VarintBEInt64Test;
+
+#ifdef GTEST_HAS_DEATH_TEST
+// These synonyms are needed for the tests that use ASSERT_DEATH
+typedef VarintBEInt32Test VarintBEInt32DeathTest;
+typedef VarintBEInt64Test VarintBEInt64DeathTest;
+#endif  // GTEST_HAS_DEATH_TEST
+
+const char VarintBETestCommon::parse_data_all_FFs[] =
+    { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
+
+const char VarintBETestCommon::parse_data_CADA1[] =
+    { 0xCA, 0xDA, 0x01 };
+
+// A macro to allow defining tests once and having them run against
+// both VarintBE<int32_t> and VarintBE<int64_t>.
+//
+#define TEMPLATE_TEST_F(TEST_TYPE, TEST_NAME) \
+    TEST_F(VarintBEInt32##TEST_TYPE, TEST_NAME) { \
+      TemplateTest##TEST_NAME(); \
+    } \
+    TEST_F(VarintBEInt64##TEST_TYPE, TEST_NAME) { \
+      TemplateTest##TEST_NAME(); \
+    } \
+    template <class CacheType> \
+    void VarintBETestTemplate<CacheType>::TemplateTest##TEST_NAME()
+
+// Encoding tests: Length(), Encode(), AppendToString(), AppendToBuffer()
+
+#ifdef GTEST_HAS_DEATH_TEST
+// This test hangs for non-debug build (DeathTest threading problem)
+TEMPLATE_TEST_F(DeathTest, DISABLED_EncodeNegative) {
+  TestEncodeInvalid(-1);
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+TEMPLATE_TEST_F(Test, EncodeZero) {
+  StartEncodingTest(/* value */ 0x00, /* expected length */ 1);
+  ExpectEncodedByte(0x00);
+  EXPECT_EQ(verify_expected_length_, verify_encoded_byte_index_);
+}
+
+TEMPLATE_TEST_F(Test, EncodeEightBits) {
+  StartEncodingTest(/* value */ 0xFF, /* expected length */ 2);
+  ExpectEncodedByte(0x81);
+  ExpectEncodedByte(0x7F);
+  EXPECT_EQ(verify_expected_length_, verify_encoded_byte_index_);
+}
+
+TEMPLATE_TEST_F(Test, EncodeCADAD1A) {
+  StartEncodingTest(/* value */ 0x0CADAD1A, /* expected length */ 4);
+  ExpectEncodedByte(0xE5);
+  ExpectEncodedByte(0xB6);
+  ExpectEncodedByte(0xDA);
+  ExpectEncodedByte(0x1A);
+  EXPECT_EQ(verify_expected_length_, verify_encoded_byte_index_);
+}
+
+TEMPLATE_TEST_F(Test, Encode32BitMaxInt) {
+  StartEncodingTest(/* value */ 0x7FFFFFFF, /* expected length */ 5);
+  ExpectEncodedByte(0x87);
+  ExpectEncodedByte(0xFF);
+  ExpectEncodedByte(0xFF);
+  ExpectEncodedByte(0xFF);
+  ExpectEncodedByte(0x7F);
+  EXPECT_EQ(verify_expected_length_, verify_encoded_byte_index_);
+}
+
+#ifdef GTEST_HAS_DEATH_TEST
+// This test hangs for non-debug build (DeathTest threading problem)
+TEST_F(VarintBEInt32DeathTest, DISABLED_Encode32BitsTooBig) {
+  TestEncodeInvalid(0x80000000);
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+TEST_F(VarintBEInt64Test, Encode32Bits) {
+  StartEncodingTest(/* value */ 0x80000000, /* expected length */ 5);
+  ExpectEncodedByte(0x88);
+  ExpectEncodedByte(0x80);
+  ExpectEncodedByte(0x80);
+  ExpectEncodedByte(0x80);
+  ExpectEncodedByte(0x00);
+  EXPECT_EQ(verify_expected_length_, verify_encoded_byte_index_);
+}
+
+TEST_F(VarintBEInt64Test, Encode63Bits) {
+  StartEncodingTest(/* value */ 0x7FFFFFFFFFFFFFFFULL, /* expected length */ 9);
+  ExpectEncodedByte(0xFF);
+  ExpectEncodedByte(0xFF);
+  ExpectEncodedByte(0xFF);
+  ExpectEncodedByte(0xFF);
+  ExpectEncodedByte(0xFF);
+  ExpectEncodedByte(0xFF);
+  ExpectEncodedByte(0xFF);
+  ExpectEncodedByte(0xFF);
+  ExpectEncodedByte(0x7F);
+  EXPECT_EQ(verify_expected_length_, verify_encoded_byte_index_);
+}
+
+#ifdef GTEST_HAS_DEATH_TEST
+// This test hangs for non-debug build (DeathTest threading problem)
+TEST_F(VarintBEInt64DeathTest, DISABLED_Encode64BitsTooBig) {
+  TestEncodeInvalid(0x8000000000000000ULL);
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+TEMPLATE_TEST_F(Test, EncodeDoesNotOverwriteExistingString) {
+  s_.append("Test");
+  VarintType::AppendToString('1', &s_);
+  EXPECT_EQ(strlen("Test1"), s_.length());
+  EXPECT_EQ("Test1", s_);
+}
+
+// Decoding tests: Parse(), ParseFromBuffer()
+
+TEMPLATE_TEST_F(Test, ParseVarintTooLong) {
+  EXPECT_EQ(RESULT_ERROR,
+            VarintType::Parse(parse_data_ptr_ + VarintType::kMaxBytes,
+                              &parse_data_ptr_));
+}
+
+TEMPLATE_TEST_F(Test, ParseIncompleteVarint) {
+  EXPECT_EQ(RESULT_END_OF_DATA,
+            VarintType::Parse(parse_data_ptr_ + VarintType::kMaxBytes - 1,
+                              &parse_data_ptr_));
+}
+
+TEMPLATE_TEST_F(Test, ParseZero) {
+  const char zero_data[] = { 0x00 };
+  parse_data_ptr_ = zero_data;
+  EXPECT_EQ(0x00, VarintType::Parse(parse_data_ptr_ + 1, &parse_data_ptr_));
+  EXPECT_EQ(zero_data + 1, parse_data_ptr_);
+}
+
+TEMPLATE_TEST_F(Test, ParseCADA1) {
+  parse_data_ptr_ = parse_data_CADA1;
+  EXPECT_EQ(0x12AD01,
+            VarintType::Parse(parse_data_CADA1 + sizeof(parse_data_CADA1),
+                              &parse_data_ptr_));
+  EXPECT_EQ(parse_data_CADA1 + 3, parse_data_ptr_);
+}
+
+#ifdef GTEST_HAS_DEATH_TEST
+TEMPLATE_TEST_F(DeathTest, ParseNullPointer) {
+  // limit == NULL is not an error
+  parse_data_ptr_ = parse_data_CADA1;
+  EXPECT_EQ(0x12AD01, VarintType::Parse((const char*) NULL, &parse_data_ptr_));
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+TEMPLATE_TEST_F(Test, EndPointerPrecedesBeginning) {
+  // This is not an error.
+  parse_data_ptr_ = parse_data_CADA1;
+  EXPECT_EQ(0x12AD01, VarintType::Parse(parse_data_ptr_ - 1, &parse_data_ptr_));
+}
+
+TEMPLATE_TEST_F(Test, ParseEmpty) {
+  EXPECT_EQ(RESULT_END_OF_DATA,
+            VarintType::Parse(parse_data_ptr_, &parse_data_ptr_));
+}
+
+// This example is taken from the Varint description in RFC 3284, section 2.
+TEMPLATE_TEST_F(Test, Parse123456789) {
+  const char parse_data_123456789[] = { 0x80 + 58, 0x80 + 111, 0x80 + 26, 21 };
+  parse_data_ptr_ = parse_data_123456789;
+  EXPECT_EQ(123456789, VarintType::Parse(parse_data_123456789
+                                             + sizeof(parse_data_123456789),
+                                         &parse_data_ptr_));
+}
+
+TEMPLATE_TEST_F(Test, Decode31Bits) {
+  const char parse_data_31_bits[] = { 0x87, 0xFF, 0xFF, 0xFF, 0x7F };
+  parse_data_ptr_ = parse_data_31_bits;
+  EXPECT_EQ(0x7FFFFFFF,
+            VarintType::Parse(parse_data_31_bits + sizeof(parse_data_31_bits),
+                              &parse_data_ptr_));
+}
+
+TEST_F(VarintBEInt32Test, Decode32Bits) {
+  const char parse_data_32_bits[] = { 0x88, 0x80, 0x80, 0x80, 0x00 };
+  parse_data_ptr_ = parse_data_32_bits;
+  EXPECT_EQ(RESULT_ERROR,
+            VarintType::Parse(parse_data_32_bits + sizeof(parse_data_32_bits),
+                              &parse_data_ptr_));
+}
+
+TEST_F(VarintBEInt64Test, Decode32Bits) {
+  const char parse_data_32_bits[] = { 0x88, 0x80, 0x80, 0x80, 0x00 };
+  parse_data_ptr_ = parse_data_32_bits;
+  EXPECT_EQ(0x80000000,
+            VarintType::Parse(parse_data_32_bits + sizeof(parse_data_32_bits),
+                              &parse_data_ptr_));
+}
+
+TEMPLATE_TEST_F(Test, EncodeDecodeRandom) {
+  const int test_size = 1024;  // 1K random encode/decode operations
+  char encode_buffer[VarintType::kMaxBytes];
+  srand(1);
+  for (int i = 0; i < test_size; ++i) {
+    SignedIntType value = PortableRandomInRange(VarintType::kMaxVal);
+    int length = VarintType::Encode(value, encode_buffer);
+    EXPECT_EQ(length, VarintType::Length(value));
+    const char* parse_pointer = encode_buffer;
+    EXPECT_EQ(value, VarintType::Parse(encode_buffer + sizeof(encode_buffer),
+                                       &parse_pointer));
+    EXPECT_EQ(encode_buffer + length, parse_pointer);
+  }
+  for (int i = 0; i < test_size; ++i) {
+    s_.clear();
+    SignedIntType value = PortableRandomInRange(VarintType::kMaxVal);
+    VarintType::AppendToString(value, &s_);
+    const int varint_length = static_cast<int>(s_.length());
+    EXPECT_EQ(VarintType::Length(value), varint_length);
+    const char* parse_pointer = s_.c_str();
+    const char* const buffer_end_pointer = s_.c_str() + s_.length();
+    EXPECT_EQ(value, VarintType::Parse(buffer_end_pointer, &parse_pointer));
+    EXPECT_EQ(buffer_end_pointer, parse_pointer);
+  }
+}
+
+}  // anonymous namespace
+}  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdecoder.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdecoder.cc
new file mode 100644
index 0000000..b5ce997
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdecoder.cc
@@ -0,0 +1,1401 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Implements a Decoder for the format described in
+// RFC 3284 - The VCDIFF Generic Differencing and Compression Data Format.
+// The RFC text can be found at http://www.faqs.org/rfcs/rfc3284.html
+//
+// The RFC describes the possibility of using a secondary compressor
+// to further reduce the size of each section of the VCDIFF output.
+// That feature is not supported in this implementation of the encoder
+// and decoder.
+// No secondary compressor types have been publicly registered with
+// the IANA at http://www.iana.org/assignments/vcdiff-comp-ids
+// in the more than five years since the registry was created, so there
+// is no standard set of compressor IDs which would be generated by other
+// encoders or accepted by other decoders.
+
+#include <config.h>
+#include "google/vcdecoder.h"
+#include <stdint.h>  // int32_t
+#include <cstddef>  // size_t, ptrdiff_t
+#include <memory>  // auto_ptr
+#include <string>
+#include "addrcache.h"
+#include "checksum.h"
+#include "codetable.h"
+#include "decodetable.h"
+#include "headerparser.h"
+#include "logging.h"
+#include "google/output_string.h"
+#include "varint_bigendian.h"
+#include "vcdiff_defs.h"
+
+namespace open_vcdiff {
+
+namespace {
+
+using std::string;
+
+enum VCDiffAnnotationType {
+  VCD_ANNOTATION_LITERAL,
+  VCD_ANNOTATION_DMATCH,
+  VCD_ANNOTATION_BMATCH
+};
+
+static const char* kAnnotationStartTags[] = {
+    "<literal>",
+    "<dmatch>",
+    "<bmatch>"
+};
+
+static const char* kAnnotationEndTags[] = {
+    "</literal>",
+    "</dmatch>",
+    "</bmatch>"
+};
+
+}  // anonymous namespace
+
+// This class is used to parse delta file windows as described
+// in RFC sections 4.2 and 4.3.  Its methods are not thread-safe.
+//
+// Here is the window format copied from the RFC:
+//
+// Window1
+//     Win_Indicator                            - byte
+//     [Source segment size]                    - integer
+//     [Source segment position]                - integer
+//     The delta encoding of the target window
+//         Length of the delta encoding         - integer
+//         The delta encoding
+//             Size of the target window        - integer
+//             Delta_Indicator                  - byte
+//             Length of data for ADDs and RUNs - integer
+//             Length of instructions and sizes - integer
+//             Length of addresses for COPYs    - integer
+//             Data section for ADDs and RUNs   - array of bytes
+//             Instructions and sizes section   - array of bytes
+//             Addresses section for COPYs      - array of bytes
+// Window2
+// ...
+//
+// Sample usage:
+//
+// VCDiffDeltaFileWindow delta_window_;
+// delta_window_.Init(parent);
+// ParseableChunk parseable_chunk(input_buffer,
+//                                input_size,
+//                                leftover_unencoded_bytes);
+// switch (delta_window_.DecodeWindows(&parseable_chunk)) {
+//   case RESULT_END_OF_DATA:
+//     <Read more input and retry DecodeWindows later.>
+//   case RESULT_ERROR:
+//     <Handle error case.  An error log message has already been generated.>
+// }
+//
+// DecodeWindows consumes as many windows from the input as it can.  It only
+// needs to be placed within a loop if the loop is used to obtain more input
+// (delta file) data.
+//
+class VCDiffDeltaFileWindow {
+ public:
+  VCDiffDeltaFileWindow();
+  ~VCDiffDeltaFileWindow();
+
+  // Init() should be called immediately after constructing the
+  // VCDiffDeltaFileWindow().  It must be called before DecodeWindows() can be
+  // invoked, or an error will occur.
+  void Init(VCDiffStreamingDecoderImpl* parent);
+
+  // Resets the pointers to the data sections in the current window.
+  void Reset();
+
+  bool UseCodeTable(const VCDiffCodeTableData& code_table_data,
+                    unsigned char max_mode) {
+    return reader_.UseCodeTable(code_table_data, max_mode);
+  }
+
+  // Decodes as many delta windows as possible using the input data from
+  // *parseable_chunk.  Appends the decoded target windows to
+  // parent_->decoded_target().  If annotated output is enabled, appends
+  // annotated output to parent_->annotated_output().  Returns RESULT_SUCCESS on
+  // success, or RESULT_END_OF_DATA if the end of input was reached before the
+  // entire window could be decoded and more input is expected (only possible if
+  // IsInterleaved() is true), or RESULT_ERROR if an error occurred during
+  // decoding.  In the RESULT_ERROR case, the value of parseable_chunk->pointer_
+  // is undefined; otherwise, parseable_chunk->Advance() is called to point to
+  // the input data position just after the data that has been decoded.
+  //
+  // If expected_target_bytes is not set to kUnlimitedBytes, then the decoder
+  // expects *exactly* this number of target bytes to be decoded from one or
+  // more delta file windows.  If this number is met exactly after finishing a
+  // delta window, this function will return RESULT_SUCCESS without processing
+  // any more bytes from data_pointer.  If this number is exceeded while
+  // decoding a window, but was not met before starting that window,
+  // then RESULT_ERROR will be returned.
+  //
+  VCDiffResult DecodeWindows(ParseableChunk* parseable_chunk);
+
+  bool FoundWindowHeader() const {
+    return found_header_;
+  }
+
+  bool MoreDataExpected() const {
+    // When parsing an interleaved-format delta file,
+    // every time DecodeBody() exits, interleaved_bytes_expected_
+    // will be decremented by the number of bytes parsed.  If it
+    // reaches zero, then there is no more data expected because
+    // the size of the interleaved section (given in the window
+    // header) has been reached.
+    return IsInterleaved() && (interleaved_bytes_expected_ > 0);
+  }
+
+  // Returns the number of bytes remaining to be decoded in the target window.
+  // If not in the process of decoding a window, returns 0.
+  size_t TargetBytesRemaining();
+
+  void EnableAnnotatedOutput() {
+    if (!annotated_output_.get()) {
+      annotated_output_.reset(new string);
+    }
+  }
+
+  void DisableAnnotatedOutput() {
+    annotated_output_.reset(NULL);
+  }
+
+ private:
+  // Reads the header of the window section as described in RFC sections 4.2 and
+  // 4.3, up to and including the value "Length of addresses for COPYs".  If the
+  // entire header is found, this function sets up the DeltaWindowSections
+  // instructions_and_sizes_, data_for_add_and_run_, and addresses_for_copy_ so
+  // that the decoder can begin decoding the opcodes in these sections.  Returns
+  // RESULT_ERROR if an error occurred, or RESULT_END_OF_DATA if the end of
+  // available data was reached before the entire header could be read.  (The
+  // latter may be an error condition if there is no more data available.)
+  // Otherwise, returns RESULT_SUCCESS and advances parseable_chunk past the
+  // parsed header.
+  //
+  VCDiffResult ReadHeader(ParseableChunk* parseable_chunk);
+
+  // After the window header has been parsed as far as the Delta_Indicator,
+  // this function is called to parse the following delta window header fields:
+  //
+  //     Length of data for ADDs and RUNs - integer (VarintBE format)
+  //     Length of instructions and sizes - integer (VarintBE format)
+  //     Length of addresses for COPYs    - integer (VarintBE format)
+  //
+  // If has_checksum_ is true, it also looks for the following element:
+  //
+  //     Adler32 checksum            - unsigned 32-bit integer (VarintBE format)
+  //
+  // It sets up the DeltaWindowSections instructions_and_sizes_,
+  // data_for_add_and_run_, and addresses_for_copy_.  If the interleaved format
+  // is being used, all three sections will include the entire window body; if
+  // the standard format is used, three non-overlapping window sections will be
+  // defined.  Returns RESULT_ERROR if an error occurred, or RESULT_END_OF_DATA
+  // if standard format is being used and there is not enough input data to read
+  // the entire window body.  Otherwise, returns RESULT_SUCCESS.
+  VCDiffResult SetUpWindowSections(VCDiffHeaderParser* header_parser);
+
+  // Decodes the body of the window section as described in RFC sections 4.3,
+  // including the sections "Data section for ADDs and RUNs", "Instructions
+  // and sizes section", and "Addresses section for COPYs".  These sections
+  // must already have been set up by ReadWindowHeader().  Returns a
+  // non-negative value on success, or RESULT_END_OF_DATA if the end of input
+  // was reached before the entire window could be decoded (only possible if
+  // IsInterleaved() is true), or RESULT_ERROR if an error occurred during
+  // decoding.  Appends as much of the decoded target window as possible to
+  // parent->decoded_target().
+  //
+  int DecodeBody(ParseableChunk* parseable_chunk);
+
+  // Returns the number of bytes already decoded into the target window.
+  size_t TargetBytesDecoded();
+
+  // Decodes a single ADD instruction, updating parent_->decoded_target_.
+  VCDiffResult DecodeAdd(size_t size);
+
+  // Decodes a single RUN instruction, updating parent_->decoded_target_.
+  VCDiffResult DecodeRun(size_t size);
+
+  // Decodes a single COPY instruction, updating parent_->decoded_target_.
+  VCDiffResult DecodeCopy(size_t size, unsigned char mode);
+
+  // When using the interleaved format, this function is called both on parsing
+  // the header and on resuming after a RESULT_END_OF_DATA was returned from a
+  // previous call to DecodeBody().  It sets up all three section pointers to
+  // reference the same interleaved stream of instructions, sizes, addresses,
+  // and data.  These pointers must be reset every time that work resumes on a
+  // delta window,  because the input data string may have been changed or
+  // resized since DecodeBody() last returned.
+  void UpdateInterleavedSectionPointers(const char* data_pos,
+                                        const char* data_end) {
+    const ptrdiff_t available_data = data_end - data_pos;
+    // Don't read past the end of currently-available data
+    if (available_data > interleaved_bytes_expected_) {
+      instructions_and_sizes_.Init(data_pos, interleaved_bytes_expected_);
+    } else {
+      instructions_and_sizes_.Init(data_pos, available_data);
+    }
+    data_for_add_and_run_.Init(&instructions_and_sizes_);
+    addresses_for_copy_.Init(&instructions_and_sizes_);
+  }
+
+  // If true, the interleaved format described in AllowInterleaved() is used
+  // for the current delta file.  Only valid after ReadWindowHeader() has been
+  // called and returned a positive number (i.e., the whole header was parsed),
+  // but before the window has finished decoding.
+  //
+  bool IsInterleaved() const {
+    // If the sections are interleaved, both addresses_for_copy_ and
+    // data_for_add_and_run_ should point at instructions_and_sizes_.
+    return !addresses_for_copy_.IsOwned();
+  }
+
+  // Executes a single COPY or ADD instruction, appending data to
+  // parent_->decoded_target().
+  void CopyBytes(const char* data,
+                 size_t size,
+                 VCDiffAnnotationType annotation_type);
+
+  // Executes a single RUN instruction, appending data to
+  // parent_->decoded_target().
+  void RunByte(unsigned char byte, size_t size);
+
+  void AppendAnnotatedOutput(string* annotated_output) {
+    if (annotated_output_.get()) {
+      annotated_output->append(*annotated_output_.get());
+    }
+  }
+
+  // Advance *parseable_chunk to point to the current position in the
+  // instructions/sizes section.  If interleaved format is used, then
+  // decrement the number of expected bytes in the instructions/sizes section
+  // by the number of instruction/size bytes parsed.
+  void UpdateInstructionPointer(ParseableChunk* parseable_chunk);
+
+  // The parent object which was passed to Init().
+  VCDiffStreamingDecoderImpl* parent_;
+
+  // This value will be true if VCDiffDeltaFileWindow::ReadDeltaWindowHeader()
+  // has been called and succeeded in parsing the delta window header, but the
+  // entire window has not yet been decoded.
+  bool found_header_;
+
+  // Contents and length of the current source window.  source_segment_ptr_
+  // will be non-NULL if (a) the window section header for the current window
+  // has been read, but the window has not yet finished decoding; or
+  // (b) the window did not specify a source segment.
+  const char* source_segment_ptr_;
+  size_t source_segment_length_;
+
+  // The delta encoding window sections as defined in RFC section 4.3.
+  // The pointer for each section will be incremented as data is consumed and
+  // decoded from that section.  If the interleaved format is used,
+  // data_for_add_and_run_ and addresses_for_copy_ will both point to
+  // instructions_and_sizes_; otherwise, they will be separate data sections.
+  //
+  DeltaWindowSection instructions_and_sizes_;
+  DeltaWindowSection data_for_add_and_run_;
+  DeltaWindowSection addresses_for_copy_;
+
+  // The expected bytes left to decode in instructions_and_sizes_.  Only used
+  // for the interleaved format.
+  int interleaved_bytes_expected_;
+
+  // The expected length of the target window once it has been decoded.
+  size_t target_window_length_;
+
+  // The index in decoded_target at which the first byte of the current
+  // target window was/will be written.
+  size_t target_window_start_pos_;
+
+  // If has_checksum_ is true, then expected_checksum_ contains an Adler32
+  // checksum of the target window data.  This is an extension included in the
+  // VCDIFF 'S' (SDCH) format, but is not part of the RFC 3284 draft standard.
+  bool has_checksum_;
+  VCDChecksum expected_checksum_;
+
+  VCDiffCodeTableReader reader_;
+
+  // This value is initialized to NULL, which means that annotated output is
+  // disabled.  If EnableAnnotatedOutput() is called, it will be set to point
+  // to a new string object, and annotated output will be gathered into that
+  // string.
+  std::auto_ptr<string> annotated_output_;
+
+  // Making these private avoids implicit copy constructor & assignment operator
+  VCDiffDeltaFileWindow(const VCDiffDeltaFileWindow&);  // NOLINT
+  void operator=(const VCDiffDeltaFileWindow&);
+};
+
+class VCDiffStreamingDecoderImpl {
+ public:
+  // A constant that is the default value for expected_target_bytes_,
+  // indicating that the decoder does not have an expected length
+  // for the target data.
+  static const size_t kUnlimitedBytes = static_cast<size_t>(-3);
+
+  VCDiffStreamingDecoderImpl();
+  ~VCDiffStreamingDecoderImpl();
+
+  // Resets all member variables to their initial states.
+  void Reset();
+
+  // These functions are identical to their counterparts
+  // in VCDiffStreamingDecoder.
+  //
+  void StartDecoding(const char* dictionary_ptr, size_t dictionary_size);
+
+  bool DecodeChunk(const char* data,
+                   size_t len,
+                   OutputStringInterface* output_string);
+
+  bool FinishDecoding();
+
+  // If true, the version of VCDIFF used in the current delta file allows
+  // for the interleaved format, in which instructions, addresses and data
+  // are all sent interleaved in the instructions section of each window
+  // rather than being sent in separate sections.  This is not part of
+  // the VCDIFF draft standard, so we've defined a special version code
+  // 'S' which implies that this feature is available.  Even if interleaving
+  // is supported, it is not mandatory; interleaved format will be implied
+  // if the address and data sections are both zero-length.
+  //
+  bool AllowInterleaved() const { return vcdiff_version_code_ == 'S'; }
+
+  // If true, the version of VCDIFF used in the current delta file allows
+  // each delta window to contain an Adler32 checksum of the target window data.
+  // If the bit 0x08 (VCD_CHECKSUM) is set in the Win_Indicator flags, then
+  // this checksum will appear as a variable-length integer, just after the
+  // "length of addresses for COPYs" value and before the window data sections.
+  // It is possible for some windows in a delta file to use the checksum feature
+  // and for others not to use it (and leave the flag bit set to 0.)
+  // Just as with AllowInterleaved(), this extension is not part of the draft
+  // standard and is only available when the version code 'S' is specified.
+  //
+  bool AllowChecksum() const { return vcdiff_version_code_ == 'S'; }
+
+  // See description of expected_target_bytes_, below.
+  bool HasTargetByteLimit() const {
+    return expected_target_bytes_ != kUnlimitedBytes;
+  }
+
+  void SetTargetByteLimit(size_t expected_target_bytes) {
+    expected_target_bytes_ = expected_target_bytes;
+  }
+
+  // Checks to see whether the decoded target data has reached the expected
+  // size.
+  bool MetTargetByteLimit() const {
+    if (!HasTargetByteLimit()) {
+      return false;
+    }
+    // The target byte limit should not have been exceeded, because each target
+    // window size is checked against that limit in ReadHeader(), and
+    // DecodeBody() will return RESULT_ERROR if the actual decoded output ever
+    // exceeds the advertised target window size.
+    if (decoded_target_.size() > expected_target_bytes_) {
+      LOG(DFATAL) << "Internal error: Decoded data size "
+                  << decoded_target_.size()
+                  << " exceeds target byte limit "
+                  << expected_target_bytes_ << LOG_ENDL;
+      return true;
+    }
+    return decoded_target_.size() == expected_target_bytes_;
+  }
+
+  // Checks to see whether adding a new target window of the specified size
+  // would exceed the expected target size.  If so, logs an error and returns
+  // true; otherwise, returns false.
+  bool TargetWindowWouldExceedTargetByteLimit(size_t window_size) const {
+    if (!HasTargetByteLimit()) {
+      return false;
+    }
+    // The logical expression to check would be:
+    //
+    //   decoded_target_.size() + target_bytes_to_add > expected_target_bytes_
+    //
+    // but the addition might cause an integer overflow if target_bytes_to_add
+    // is very large.  So it is better to check target_bytes_to_add against
+    // the remaining expected target bytes.
+    size_t remaining_expected_target_bytes =
+        expected_target_bytes_ - decoded_target_.size();
+    if (window_size > remaining_expected_target_bytes) {
+      LOG(ERROR) << "Length of target window (" << window_size
+                 << " bytes) plus previous windows (" << decoded_target_.size()
+                 << " bytes) would exceed expected size of "
+                 << expected_target_bytes_ << " bytes" << LOG_ENDL;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  // Returns the amount of input data passed to the last DecodeChunk()
+  // that was not consumed by the decoder.  This is essential if
+  // SetExpectedTargetBytes() is being used, in order to preserve
+  // the input data stream beyond the expected encoding.
+  size_t GetUnconsumedDataSize() const {
+    return unparsed_bytes_.size();
+  }
+
+  // This function will return true if the decoder has parsed a complete delta
+  // file header plus zero or more delta file windows, with no data left over.
+  // It will also return true if no delta data at all was decoded.  If these
+  // conditions are not met, then FinishDecoding() should not be called.
+  bool IsDecodingComplete() const {
+    if (!FoundFileHeader()) {
+      // No complete delta file header has been parsed yet.  DecodeChunk()
+      // may have received some data that it hasn't yet parsed, in which case
+      // decoding is incomplete.
+      return unparsed_bytes_.empty();
+    } else if (custom_code_table_decoder_.get()) {
+      // The decoder is in the middle of parsing a custom code table.
+      return false;
+    } else if (delta_window_.FoundWindowHeader()) {
+      // The decoder is in the middle of parsing an interleaved format delta
+      // window.
+      return false;
+    } else if (MetTargetByteLimit()) {
+      // The decoder found exactly the expected number of bytes.  In this case
+      // it is OK for unparsed_bytes_ to be non-empty; it contains the leftover
+      // data after the end of the delta file.
+      return true;
+    } else {
+      // No complete delta file window has been parsed yet.  DecodeChunk()
+      // may have received some data that it hasn't yet parsed, in which case
+      // decoding is incomplete.
+      return unparsed_bytes_.empty();
+    }
+  }
+
+  const char* dictionary_ptr() const { return dictionary_ptr_; }
+
+  size_t dictionary_size() const { return dictionary_size_; }
+
+  VCDiffAddressCache* addr_cache() { return addr_cache_.get(); }
+
+  string* decoded_target() { return &decoded_target_; }
+
+  string* annotated_output() { return &annotated_output_; }
+
+  // The variable that determines whether annotated output is enabled is
+  // delta_window_.annotated_output_.  If that member is NULL, then the feature
+  // is disabled.
+  void EnableAnnotatedOutput() {
+    delta_window_.EnableAnnotatedOutput();
+  }
+
+  void DisableAnnotatedOutput() {
+    delta_window_.DisableAnnotatedOutput();
+  }
+
+  void GetAnnotatedOutput(OutputStringInterface* annotated_output) {
+    // We could use annotated_output->assign(), but that method is not defined
+    // for some output string types, so use clear() + append() to accomplish the
+    // same thing.
+    annotated_output->clear();
+    annotated_output->append(annotated_output_.data(),
+                             annotated_output_.size());
+  }
+
+ private:
+  // Reads the VCDiff delta file header section as described in RFC section 4.1,
+  // except the custom code table data.  Returns RESULT_ERROR if an error
+  // occurred, or RESULT_END_OF_DATA if the end of available data was reached
+  // before the entire header could be read.  (The latter may be an error
+  // condition if there is no more data available.)  Otherwise, advances
+  // data->position_ past the header and returns RESULT_SUCCESS.
+  //
+  VCDiffResult ReadDeltaFileHeader(ParseableChunk* data);
+
+  // Indicates whether or not the header has already been read.
+  bool FoundFileHeader() const { return addr_cache_.get() != NULL; }
+
+  // If ReadDeltaFileHeader() finds the VCD_CODETABLE flag set within the delta
+  // file header, this function parses the custom cache sizes and initializes
+  // a nested VCDiffStreamingDecoderImpl object that will be used to parse the
+  // custom code table in ReadCustomCodeTable().  Returns RESULT_ERROR if an
+  // error occurred, or RESULT_END_OF_DATA if the end of available data was
+  // reached before the custom cache sizes could be read.  Otherwise, returns
+  // the number of bytes read.
+  //
+  int InitCustomCodeTable(const char* data_start, const char* data_end);
+
+  // If a custom code table was specified in the header section that was parsed
+  // by ReadDeltaFileHeader(), this function makes a recursive call to another
+  // VCDiffStreamingDecoderImpl object (custom_code_table_decoder_), since the
+  // custom code table is expected to be supplied as an embedded VCDIFF
+  // encoding that uses the standard code table.  Returns RESULT_ERROR if an
+  // error occurs, or RESULT_END_OF_DATA if the end of available data was
+  // reached before the entire custom code table could be read.  Otherwise,
+  // returns RESULT_SUCCESS and sets *data_ptr to the position after the encoded
+  // custom code table.  If the function returns RESULT_SUCCESS or
+  // RESULT_END_OF_DATA, it advances data->position_ past the parsed bytes.
+  //
+  VCDiffResult ReadCustomCodeTable(ParseableChunk* data);
+
+  // Contents and length of the source (dictionary) data.
+  const char* dictionary_ptr_;
+  size_t dictionary_size_;
+
+  // This string will be used to store any unparsed bytes left over when
+  // DecodeChunk() reaches the end of its input and returns RESULT_END_OF_DATA.
+  // It will also be used to concatenate those unparsed bytes with the data
+  // supplied to the next call to DecodeChunk(), so that they appear in
+  // contiguous memory.
+  string unparsed_bytes_;
+
+  // The portion of the target file that has been decoded so far.  This will be
+  // used to fill the output string for DecodeChunk(), and will also be used to
+  // execute COPY instructions that reference target data.  Since the source
+  // window can come from a range of addresses in the previously decoded target
+  // data, the entire target file needs to be available to the decoder, not just
+  // the current target window.
+  string decoded_target_;
+
+  // The VCDIFF version byte (also known as "header4") from the
+  // delta file header.
+  unsigned char vcdiff_version_code_;
+
+  VCDiffDeltaFileWindow delta_window_;
+
+  std::auto_ptr<VCDiffAddressCache> addr_cache_;
+
+  // Will be NULL unless a custom code table has been defined.
+  std::auto_ptr<VCDiffCodeTableData> custom_code_table_;
+
+  // Used to receive the decoded custom code table.
+  string custom_code_table_string_;
+
+  // If a custom code table is specified, it will be expressed
+  // as an embedded VCDIFF delta file which uses the default code table
+  // as the source file (dictionary).  Use a child decoder object
+  // to decode that delta file.
+  std::auto_ptr<VCDiffStreamingDecoderImpl> custom_code_table_decoder_;
+
+  // If set, then the decoder is expecting *exactly* this number of
+  // target bytes to be decoded from one or more delta file windows.
+  // If this number is exceeded while decoding a window, but was not met
+  // before starting on that window, an error will be reported.
+  // If FinishDecoding() is called before this number is met, an error
+  // will also be reported.  This feature is used for decoding the
+  // embedded code table data within a VCDIFF delta file; we want to
+  // stop processing the embedded data once the entire code table has
+  // been decoded, and treat the rest of the available data as part
+  // of the enclosing delta file.
+  size_t expected_target_bytes_;
+
+  // This string will always be empty until EnableAnnotatedOutput() is called,
+  // at which point it will start to accumulate annotated delta windows each
+  // time DecodeChunk() finishes a window.  It will be cleared each time that
+  // StartDecoding() is called.
+  string annotated_output_;
+
+  // This value is used to ensure the correct order of calls to the interface
+  // functions, i.e., a single call to StartDecoding(), followed by zero or
+  // more calls to DecodeChunk(), followed by a single call to
+  // FinishDecoding().
+  bool start_decoding_was_called_;
+
+  // Making these private avoids implicit copy constructor & assignment operator
+  VCDiffStreamingDecoderImpl(const VCDiffStreamingDecoderImpl&);  // NOLINT
+  void operator=(const VCDiffStreamingDecoderImpl&);
+};
+
+// *** Methods for VCDiffStreamingDecoderImpl
+
+VCDiffStreamingDecoderImpl::VCDiffStreamingDecoderImpl() {
+  delta_window_.Init(this);
+  Reset();
+}
+
+// Reset() will delete the component objects without reallocating them.
+VCDiffStreamingDecoderImpl::~VCDiffStreamingDecoderImpl() { Reset(); }
+
+void VCDiffStreamingDecoderImpl::Reset() {
+  start_decoding_was_called_ = false;
+  dictionary_ptr_ = NULL;
+  dictionary_size_ = 0;
+  vcdiff_version_code_ = '\0';
+  expected_target_bytes_ = kUnlimitedBytes;
+  addr_cache_.reset();
+  custom_code_table_.reset();
+  custom_code_table_decoder_.reset();
+  delta_window_.Reset();
+}
+
+void VCDiffStreamingDecoderImpl::StartDecoding(const char* dictionary_ptr,
+                                               size_t dictionary_size) {
+  if (start_decoding_was_called_) {
+    LOG(DFATAL) << "StartDecoding() called twice without FinishDecoding()"
+                << LOG_ENDL;
+    return;
+  }
+  unparsed_bytes_.clear();
+  decoded_target_.clear();  // delta_window_.Reset() depends on this
+  annotated_output_.clear();
+  Reset();
+  dictionary_ptr_ = dictionary_ptr;
+  dictionary_size_ = dictionary_size;
+  start_decoding_was_called_ = true;
+}
+
+// Reads the VCDiff delta file header section as described in RFC section 4.1:
+//
+//     Header1                                  - byte = 0xD6 (ASCII 'V' | 0x80)
+//     Header2                                  - byte = 0xC3 (ASCII 'C' | 0x80)
+//     Header3                                  - byte = 0xC4 (ASCII 'D' | 0x80)
+//     Header4                                  - byte
+//     Hdr_Indicator                            - byte
+//     [Secondary compressor ID]                - byte
+//     [Length of code table data]              - integer
+//     [Code table data]
+//
+// Initializes the code table and address cache objects.  Returns RESULT_ERROR
+// if an error occurred, and RESULT_END_OF_DATA if the end of available data was
+// reached before the entire header could be read.  (The latter may be an error
+// condition if there is no more data available.)  Otherwise, returns
+// RESULT_SUCCESS, and removes the header bytes from the data string.
+//
+// It's relatively inefficient to expect this function to parse any number of
+// input bytes available, down to 1 byte, but it is necessary in case the input
+// is not a properly formatted VCDIFF delta file.  If the entire input consists
+// of two bytes "12", then we should recognize that it does not match the
+// initial VCDIFF magic number "VCD" and report an error, rather than waiting
+// indefinitely for more input that will never arrive.
+//
+VCDiffResult VCDiffStreamingDecoderImpl::ReadDeltaFileHeader(
+    ParseableChunk* data) {
+  if (FoundFileHeader()) {
+    return RESULT_SUCCESS;
+  }
+  size_t data_size = data->UnparsedSize();
+  const DeltaFileHeader* header =
+      reinterpret_cast<const DeltaFileHeader*>(data->UnparsedData());
+  bool wrong_magic_number = false;
+  switch (data_size) {
+    // Verify only the bytes that are available.
+    default:
+      // Found header contents up to and including VCDIFF version
+      vcdiff_version_code_ = header->header4;
+      if ((vcdiff_version_code_ != 0x00) &&  // Draft standard VCDIFF (RFC 3284)
+          (vcdiff_version_code_ != 'S')) {   // Enhancements for SDCH protocol
+        LOG(ERROR) << "Unrecognized VCDIFF format version" << LOG_ENDL;
+        return RESULT_ERROR;
+      }
+      // fall through
+    case 3:
+      if (header->header3 != 0xC4) {  // magic value 'D' | 0x80
+        wrong_magic_number = true;
+      }
+      // fall through
+    case 2:
+      if (header->header2 != 0xC3) {  // magic value 'C' | 0x80
+        wrong_magic_number = true;
+      }
+      // fall through
+    case 1:
+      if (header->header1 != 0xD6) {  // magic value 'V' | 0x80
+        wrong_magic_number = true;
+      }
+      // fall through
+    case 0:
+      if (wrong_magic_number) {
+        LOG(ERROR) << "Did not find VCDIFF header bytes; "
+                      "input is not a VCDIFF delta file" << LOG_ENDL;
+        return RESULT_ERROR;
+      }
+      if (data_size < sizeof(DeltaFileHeader)) return RESULT_END_OF_DATA;
+  }
+  // Secondary compressor not supported.
+  if (header->hdr_indicator & VCD_DECOMPRESS) {
+    LOG(ERROR) << "Secondary compression is not supported" << LOG_ENDL;
+    return RESULT_ERROR;
+  }
+  if (header->hdr_indicator & VCD_CODETABLE) {
+    int bytes_parsed = InitCustomCodeTable(
+        data->UnparsedData() + sizeof(DeltaFileHeader),
+        data->End());
+    switch (bytes_parsed) {
+      case RESULT_ERROR:
+        return RESULT_ERROR;
+      case RESULT_END_OF_DATA:
+        return RESULT_END_OF_DATA;
+      default:
+        data->Advance(sizeof(DeltaFileHeader) + bytes_parsed);
+    }
+  } else {
+    addr_cache_.reset(new VCDiffAddressCache);
+    // addr_cache_->Init() will be called
+    // from VCDiffStreamingDecoderImpl::DecodeChunk()
+    data->Advance(sizeof(DeltaFileHeader));
+  }
+  return RESULT_SUCCESS;
+}
+
+int VCDiffStreamingDecoderImpl::InitCustomCodeTable(const char* data_start,
+                                                    const char* data_end) {
+  // A custom code table is being specified.  Parse the variable-length
+  // cache sizes and begin parsing the encoded custom code table.
+  int32_t near_cache_size = 0, same_cache_size = 0;
+  VCDiffHeaderParser header_parser(data_start, data_end);
+  if (!header_parser.ParseInt32("size of near cache", &near_cache_size)) {
+    return header_parser.GetResult();
+  }
+  if (!header_parser.ParseInt32("size of same cache", &same_cache_size)) {
+    return header_parser.GetResult();
+  }
+  custom_code_table_.reset(new struct VCDiffCodeTableData);
+  memset(custom_code_table_.get(), 0, sizeof(struct VCDiffCodeTableData));
+  custom_code_table_string_.clear();
+  addr_cache_.reset(new VCDiffAddressCache(near_cache_size, same_cache_size));
+  // addr_cache_->Init() will be called
+  // from VCDiffStreamingDecoderImpl::DecodeChunk()
+
+  // If we reach this point (the start of the custom code table)
+  // without encountering a RESULT_END_OF_DATA condition, then we won't call
+  // ReadDeltaFileHeader() again for this delta file.
+  //
+  // Instantiate a recursive decoder to interpret the custom code table
+  // as a VCDIFF encoding of the default code table.
+  custom_code_table_decoder_.reset(new VCDiffStreamingDecoderImpl);
+  custom_code_table_decoder_->StartDecoding(
+      reinterpret_cast<const char*>(
+          &VCDiffCodeTableData::kDefaultCodeTableData),
+      sizeof(VCDiffCodeTableData::kDefaultCodeTableData));
+  custom_code_table_decoder_->SetTargetByteLimit(sizeof(*custom_code_table_));
+  return static_cast<int>(header_parser.ParsedSize());
+}
+
+VCDiffResult VCDiffStreamingDecoderImpl::ReadCustomCodeTable(
+    ParseableChunk* data) {
+  if (!custom_code_table_decoder_.get()) {
+    return RESULT_SUCCESS;
+  }
+  if (!custom_code_table_.get()) {
+    LOG(DFATAL) << "Internal error:  custom_code_table_decoder_ is set,"
+                   " but custom_code_table_ is NULL" << LOG_ENDL;
+    return RESULT_ERROR;
+  }
+  OutputString<string> output_string(&custom_code_table_string_);
+  if (!custom_code_table_decoder_->DecodeChunk(data->UnparsedData(),
+                                               data->UnparsedSize(),
+                                               &output_string)) {
+    return RESULT_ERROR;
+  }
+  if (custom_code_table_string_.length() < sizeof(*custom_code_table_)) {
+    // Skip over the consumed data.
+    data->Finish();
+    return RESULT_END_OF_DATA;
+  }
+  if (!custom_code_table_decoder_->FinishDecoding()) {
+    return RESULT_ERROR;
+  }
+  if (custom_code_table_string_.length() != sizeof(*custom_code_table_)) {
+    LOG(DFATAL) << "Decoded custom code table size "
+                << custom_code_table_string_.length()
+                << " does not match expected size "
+                << sizeof(*custom_code_table_) << LOG_ENDL;
+    return RESULT_ERROR;
+  }
+  memcpy(custom_code_table_.get(),
+         custom_code_table_string_.data(),
+         sizeof(*custom_code_table_));
+  custom_code_table_string_.clear();
+  // Skip over the consumed data.
+  data->FinishExcept(custom_code_table_decoder_->GetUnconsumedDataSize());
+  custom_code_table_decoder_.reset();
+  delta_window_.UseCodeTable(*custom_code_table_, addr_cache_->LastMode());
+  return RESULT_SUCCESS;
+}
+
+namespace {
+
+class TrackNewOutputText {
+ public:
+  explicit TrackNewOutputText(const string& decoded_target)
+      : decoded_target_(decoded_target),
+      initial_decoded_target_size_(decoded_target.size()) { }
+
+  void AppendNewOutputText(size_t target_bytes_remaining,
+                           OutputStringInterface* output_string) {
+    const size_t bytes_decoded_this_chunk =
+        decoded_target_.size() - initial_decoded_target_size_;
+    if (bytes_decoded_this_chunk > 0) {
+      if (target_bytes_remaining > 0) {
+        // The decoder is midway through decoding a target window.  Resize
+        // output_string to match the expected length.  The interface guarantees
+        // not to resize the output_string more than once per target window
+        // decoded.
+        output_string->ReserveAdditionalBytes(bytes_decoded_this_chunk
+                                              + target_bytes_remaining);
+      }
+      output_string->append(
+          decoded_target_.data() + initial_decoded_target_size_,
+          bytes_decoded_this_chunk);
+    }
+  }
+
+ private:
+  const string& decoded_target_;
+  size_t initial_decoded_target_size_;
+};
+
+}  // anonymous namespace
+
+bool VCDiffStreamingDecoderImpl::DecodeChunk(
+    const char* data,
+    size_t len,
+    OutputStringInterface* output_string) {
+  if (!start_decoding_was_called_) {
+    LOG(DFATAL) << "DecodeChunk() called without StartDecoding()" << LOG_ENDL;
+    Reset();
+    return false;
+  }
+  ParseableChunk parseable_chunk(data, len);
+  if (!unparsed_bytes_.empty()) {
+    unparsed_bytes_.append(data, len);
+    parseable_chunk.SetDataBuffer(unparsed_bytes_.data(),
+                                  unparsed_bytes_.size());
+  }
+  TrackNewOutputText output_tracker(decoded_target_);
+  VCDiffResult result = ReadDeltaFileHeader(&parseable_chunk);
+  if (RESULT_SUCCESS == result) {
+    result = ReadCustomCodeTable(&parseable_chunk);
+  }
+  if (RESULT_SUCCESS == result) {
+    result = delta_window_.DecodeWindows(&parseable_chunk);
+  }
+  if (RESULT_ERROR == result) {
+    Reset();  // Don't allow further DecodeChunk calls
+    return false;
+  }
+  unparsed_bytes_.assign(parseable_chunk.UnparsedData(),
+                         parseable_chunk.UnparsedSize());
+  output_tracker.AppendNewOutputText(delta_window_.TargetBytesRemaining(),
+                                     output_string);
+  return true;
+}
+
+// Finishes decoding after all data has been received.  Returns true
+// if decoding of the entire stream was successful.
+bool VCDiffStreamingDecoderImpl::FinishDecoding() {
+  bool success = true;
+  if (!start_decoding_was_called_) {
+    LOG(WARNING) << "FinishDecoding() called before StartDecoding(),"
+                    " or called after DecodeChunk() returned false"
+                 << LOG_ENDL;
+    success = false;
+  } else if (!IsDecodingComplete()) {
+    LOG(ERROR) << "FinishDecoding() called before parsing entire"
+                  " delta file window" << LOG_ENDL;
+    success = false;
+  }
+  // Reset the object state for the next decode operation
+  Reset();
+  return success;
+}
+
+// *** Methods for VCDiffDeltaFileWindow
+
+inline VCDiffDeltaFileWindow::VCDiffDeltaFileWindow() : parent_(NULL) {
+  Reset();
+}
+
+inline VCDiffDeltaFileWindow::~VCDiffDeltaFileWindow() { }
+
+inline void VCDiffDeltaFileWindow::Init(VCDiffStreamingDecoderImpl* parent) {
+  parent_ = parent;
+}
+
+void VCDiffDeltaFileWindow::Reset() {
+  found_header_ = false;
+
+  // Mark the start of the current target window.
+  target_window_start_pos_ = parent_ ? parent_->decoded_target()->size() : 0U;
+  target_window_length_ = 0;
+
+  source_segment_ptr_ = NULL;
+  source_segment_length_ = 0;
+
+  instructions_and_sizes_.Invalidate();
+  data_for_add_and_run_.Invalidate();
+  addresses_for_copy_.Invalidate();
+
+  interleaved_bytes_expected_ = 0;
+
+  has_checksum_ = false;
+  expected_checksum_ = 0;
+  if (annotated_output_.get()) {
+    annotated_output_->clear();
+  }
+}
+
+VCDiffResult VCDiffDeltaFileWindow::SetUpWindowSections(
+    VCDiffHeaderParser* header_parser) {
+  size_t add_and_run_data_length = 0;
+  size_t instructions_and_sizes_length = 0;
+  size_t addresses_length = 0;
+  if (!header_parser->ParseSectionLengths(has_checksum_,
+                                          &add_and_run_data_length,
+                                          &instructions_and_sizes_length,
+                                          &addresses_length,
+                                          &expected_checksum_)) {
+    return header_parser->GetResult();
+  }
+  if (parent_->AllowInterleaved() &&
+      (add_and_run_data_length == 0) &&
+      (addresses_length == 0)) {
+    // The interleaved format is being used.
+    interleaved_bytes_expected_ =
+        static_cast<int>(instructions_and_sizes_length);
+    UpdateInterleavedSectionPointers(header_parser->UnparsedData(),
+                                     header_parser->End());
+  } else {
+    // If interleaved format is not used, then the whole window contents
+    // must be available before decoding can begin.  If only part of
+    // the current window is available, then report end of data
+    // and re-parse the whole header when DecodeChunk() is called again.
+    if (header_parser->UnparsedSize() < (add_and_run_data_length +
+                                         instructions_and_sizes_length +
+                                         addresses_length)) {
+      return RESULT_END_OF_DATA;
+    }
+    data_for_add_and_run_.Init(header_parser->UnparsedData(),
+                               add_and_run_data_length);
+    instructions_and_sizes_.Init(data_for_add_and_run_.End(),
+                                 instructions_and_sizes_length);
+    addresses_for_copy_.Init(instructions_and_sizes_.End(), addresses_length);
+    if (addresses_for_copy_.End() != header_parser->EndOfDeltaWindow()) {
+      LOG(ERROR) << "The end of the instructions section "
+                     "does not match the end of the delta window" << LOG_ENDL;
+      return RESULT_ERROR;
+    }
+  }
+  reader_.Init(instructions_and_sizes_.UnparsedDataAddr(),
+               instructions_and_sizes_.End());
+  return RESULT_SUCCESS;
+}
+
+// Here are the elements of the delta window header to be parsed,
+// from section 4 of the RFC:
+//
+//     Window1
+//         Win_Indicator                            - byte
+//         [Source segment size]                    - integer
+//         [Source segment position]                - integer
+//         The delta encoding of the target window
+//             Length of the delta encoding         - integer
+//             The delta encoding
+//                 Size of the target window        - integer
+//                 Delta_Indicator                  - byte
+//                 Length of data for ADDs and RUNs - integer
+//                 Length of instructions and sizes - integer
+//                 Length of addresses for COPYs    - integer
+//                 Data section for ADDs and RUNs   - array of bytes
+//                 Instructions and sizes section   - array of bytes
+//                 Addresses section for COPYs      - array of bytes
+//
+VCDiffResult VCDiffDeltaFileWindow::ReadHeader(
+    ParseableChunk* parseable_chunk) {
+  string* decoded_target = parent_->decoded_target();
+  VCDiffHeaderParser header_parser(parseable_chunk->UnparsedData(),
+                                   parseable_chunk->End());
+  size_t source_segment_position = 0;
+  unsigned char win_indicator = 0;
+  if (!header_parser.ParseWinIndicatorAndSourceSegment(
+          parent_->dictionary_size(),
+          decoded_target->size(),
+          &win_indicator,
+          &source_segment_length_,
+          &source_segment_position)) {
+    return header_parser.GetResult();
+  }
+  has_checksum_ = parent_->AllowChecksum() && (win_indicator & VCD_CHECKSUM);
+  if (!header_parser.ParseWindowLengths(&target_window_length_)) {
+    return header_parser.GetResult();
+  }
+  if (parent_->TargetWindowWouldExceedTargetByteLimit(target_window_length_)) {
+    // An error has been logged by TargetWindowWouldExceedTargetByteLimit().
+    return RESULT_ERROR;
+  }
+  header_parser.ParseDeltaIndicator();
+  VCDiffResult setup_return_code = SetUpWindowSections(&header_parser);
+  if (RESULT_SUCCESS != setup_return_code) {
+    return setup_return_code;
+  }
+  // Reserve enough space in the output string for the current target window.
+  decoded_target->reserve(target_window_start_pos_ + target_window_length_);
+  // Get a pointer to the start of the source segment.
+  if (win_indicator & VCD_SOURCE) {
+    source_segment_ptr_ = parent_->dictionary_ptr() + source_segment_position;
+  } else if (win_indicator & VCD_TARGET) {
+    // This assignment must happen after the reserve().
+    // decoded_target should not be resized again while processing this window,
+    // so source_segment_ptr_ should remain valid.
+    source_segment_ptr_ = decoded_target->data() + source_segment_position;
+  }
+  // The whole window header was found and parsed successfully.
+  found_header_ = true;
+  parseable_chunk->Advance(header_parser.ParsedSize());
+  return RESULT_SUCCESS;
+}
+
+void VCDiffDeltaFileWindow::UpdateInstructionPointer(
+    ParseableChunk* parseable_chunk) {
+  if (IsInterleaved()) {
+    size_t bytes_parsed = instructions_and_sizes_.ParsedSize();
+    // Reduce expected instruction segment length by bytes parsed
+    interleaved_bytes_expected_ -= static_cast<int>(bytes_parsed);
+    parseable_chunk->Advance(bytes_parsed);
+  }
+}
+
+size_t VCDiffDeltaFileWindow::TargetBytesDecoded() {
+  return parent_->decoded_target()->size() - target_window_start_pos_;
+}
+
+size_t VCDiffDeltaFileWindow::TargetBytesRemaining() {
+  if (target_window_length_ == 0) {
+    // There is no window being decoded at present
+    return 0;
+  } else {
+    return target_window_length_ - TargetBytesDecoded();
+  }
+}
+
+void VCDiffDeltaFileWindow::CopyBytes(const char* data,
+                                      size_t size,
+                                      VCDiffAnnotationType annotation_type) {
+  parent_->decoded_target()->append(data, size);
+  if (annotated_output_.get()) {
+    annotated_output_->append(kAnnotationStartTags[annotation_type]);
+    annotated_output_->append(data, size);
+    annotated_output_->append(kAnnotationEndTags[annotation_type]);
+  }
+}
+
+void VCDiffDeltaFileWindow::RunByte(unsigned char byte, size_t size) {
+  parent_->decoded_target()->append(size, byte);
+  if (annotated_output_.get()) {
+    annotated_output_->append(kAnnotationStartTags[VCD_ANNOTATION_LITERAL]);
+    annotated_output_->append(size, byte);
+    annotated_output_->append(kAnnotationEndTags[VCD_ANNOTATION_LITERAL]);
+  }
+}
+
+VCDiffResult VCDiffDeltaFileWindow::DecodeAdd(size_t size) {
+  if (size > data_for_add_and_run_.UnparsedSize()) {
+    return RESULT_END_OF_DATA;
+  }
+  // Write the next "size" data bytes
+  CopyBytes(data_for_add_and_run_.UnparsedData(), size, VCD_ANNOTATION_LITERAL);
+  data_for_add_and_run_.Advance(size);
+  return RESULT_SUCCESS;
+}
+
+VCDiffResult VCDiffDeltaFileWindow::DecodeRun(size_t size) {
+  if (data_for_add_and_run_.Empty()) {
+    return RESULT_END_OF_DATA;
+  }
+  // Write "size" copies of the next data byte
+  RunByte(*data_for_add_and_run_.UnparsedData(), size);
+  data_for_add_and_run_.Advance(1);
+  return RESULT_SUCCESS;
+}
+
+VCDiffResult VCDiffDeltaFileWindow::DecodeCopy(size_t size,
+                                               unsigned char mode) {
+  // Keep track of the number of target bytes decoded as a local variable
+  // to avoid recalculating it each time it is needed.
+  size_t target_bytes_decoded = TargetBytesDecoded();
+  const VCDAddress here_address =
+      static_cast<VCDAddress>(source_segment_length_ + target_bytes_decoded);
+  const VCDAddress decoded_address = parent_->addr_cache()->DecodeAddress(
+      here_address,
+      mode,
+      addresses_for_copy_.UnparsedDataAddr(),
+      addresses_for_copy_.End());
+  switch (decoded_address) {
+    case RESULT_ERROR:
+      LOG(ERROR) << "Unable to decode address for COPY" << LOG_ENDL;
+      return RESULT_ERROR;
+    case RESULT_END_OF_DATA:
+      return RESULT_END_OF_DATA;
+    default:
+      if ((decoded_address < 0) || (decoded_address > here_address)) {
+        LOG(DFATAL) << "Internal error: unexpected address " << decoded_address
+                    << " returned from DecodeAddress, with here_address = "
+                    << here_address << LOG_ENDL;
+        return RESULT_ERROR;
+      }
+      break;
+  }
+  size_t address = static_cast<size_t>(decoded_address);
+  if ((address + size) <= source_segment_length_) {
+    // Copy all data from source segment
+    CopyBytes(&source_segment_ptr_[address], size, VCD_ANNOTATION_DMATCH);
+    return RESULT_SUCCESS;
+  }
+  // Copy some data from target window...
+  if (address < source_segment_length_) {
+    // ... plus some data from source segment
+    const size_t partial_copy_size = source_segment_length_ - address;
+    CopyBytes(&source_segment_ptr_[address],
+              partial_copy_size,
+              VCD_ANNOTATION_DMATCH);
+    target_bytes_decoded += partial_copy_size;
+    address += partial_copy_size;
+    size -= partial_copy_size;
+  }
+  address -= source_segment_length_;
+  // address is now based at start of target window
+  const char* const target_segment_ptr = parent_->decoded_target()->data() +
+                                         target_window_start_pos_;
+  while (size > (target_bytes_decoded - address)) {
+    // Recursive copy that extends into the yet-to-be-copied target data
+    const size_t partial_copy_size = target_bytes_decoded - address;
+    CopyBytes(&target_segment_ptr[address],
+              partial_copy_size,
+              VCD_ANNOTATION_BMATCH);
+    target_bytes_decoded += partial_copy_size;
+    address += partial_copy_size;
+    size -= partial_copy_size;
+  }
+  CopyBytes(&target_segment_ptr[address], size, VCD_ANNOTATION_BMATCH);
+  return RESULT_SUCCESS;
+}
+
+int VCDiffDeltaFileWindow::DecodeBody(ParseableChunk* parseable_chunk) {
+  if (IsInterleaved() && (instructions_and_sizes_.UnparsedData()
+                              != parseable_chunk->UnparsedData())) {
+    LOG(DFATAL) << "Internal error: interleaved format is used, but the"
+                   " input pointer does not point to the instructions section"
+                << LOG_ENDL;
+    return RESULT_ERROR;
+  }
+  while (TargetBytesDecoded() < target_window_length_) {
+    int32_t decoded_size = VCD_INSTRUCTION_ERROR;
+    unsigned char mode = 0;
+    VCDiffInstructionType instruction =
+        reader_.GetNextInstruction(&decoded_size, &mode);
+    switch (instruction) {
+      case VCD_INSTRUCTION_END_OF_DATA:
+        UpdateInstructionPointer(parseable_chunk);
+        return RESULT_END_OF_DATA;
+      case VCD_INSTRUCTION_ERROR:
+        return RESULT_ERROR;
+      default:
+        break;
+    }
+    const size_t size = static_cast<size_t>(decoded_size);
+    // The value of "size" itself could be enormous (say, INT32_MAX)
+    // so check it individually against the limit to protect against
+    // overflow when adding it to something else.
+    if ((size > target_window_length_) ||
+        ((size + TargetBytesDecoded()) > target_window_length_)) {
+      LOG(ERROR) << VCDiffInstructionName(instruction)
+                 << " with size " << size
+                 << " plus existing " << TargetBytesDecoded()
+                 << " bytes of target data exceeds length of target"
+                    " window (" << target_window_length_ << " bytes)"
+                 << LOG_ENDL;
+      return RESULT_ERROR;
+    }
+    VCDiffResult result = RESULT_SUCCESS;
+    switch (instruction) {
+      case VCD_ADD:
+        result = DecodeAdd(size);
+        break;
+      case VCD_RUN:
+        result = DecodeRun(size);
+        break;
+      case VCD_COPY:
+        result = DecodeCopy(size, mode);
+        break;
+      default:
+        LOG(DFATAL) << "Unexpected instruction type " << instruction
+                    << "in opcode stream" << LOG_ENDL;
+        return RESULT_ERROR;
+    }
+    switch (result) {
+      case RESULT_END_OF_DATA:
+        reader_.UnGetInstruction();
+        UpdateInstructionPointer(parseable_chunk);
+        return RESULT_END_OF_DATA;
+      case RESULT_ERROR:
+        return RESULT_ERROR;
+      case RESULT_SUCCESS:
+        break;
+    }
+  }
+  if (TargetBytesDecoded() != target_window_length_) {
+    LOG(ERROR) << "Decoded target window size (" << TargetBytesDecoded()
+               << " bytes) does not match expected size ("
+               << target_window_length_ << " bytes)" << LOG_ENDL;
+    return RESULT_ERROR;
+  }
+  const char* const target_window_start =
+      parent_->decoded_target()->data() + target_window_start_pos_;
+  if (has_checksum_ &&
+      (ComputeAdler32(target_window_start, target_window_length_)
+           != expected_checksum_)) {
+    LOG(ERROR) << "Target data does not match checksum; this could mean "
+                  "that the wrong dictionary was used" << LOG_ENDL;
+    return RESULT_ERROR;
+  }
+  if (!instructions_and_sizes_.Empty()) {
+    LOG(ERROR) << "Excess instructions and sizes left over "
+                  "after decoding target window" << LOG_ENDL;
+      return RESULT_ERROR;
+  }
+  if (!IsInterleaved()) {
+    // Standard format is being used, with three separate sections for the
+    // instructions, data, and addresses.
+    if (!data_for_add_and_run_.Empty()) {
+      LOG(ERROR) << "Excess ADD/RUN data left over "
+                    "after decoding target window" << LOG_ENDL;
+        return RESULT_ERROR;
+    }
+    if (!addresses_for_copy_.Empty()) {
+      LOG(ERROR) << "Excess COPY addresses left over "
+                    "after decoding target window" << LOG_ENDL;
+        return RESULT_ERROR;
+    }
+    // Reached the end of the window.  Update the ParseableChunk to point to the
+    // end of the addresses section, which is the last section in the window.
+    parseable_chunk->SetPosition(addresses_for_copy_.End());
+  } else {
+    // Interleaved format is being used.  The window may have been only
+    // partially decoded.
+    UpdateInstructionPointer(parseable_chunk);
+  }
+  return RESULT_SUCCESS;
+}
+
+VCDiffResult VCDiffDeltaFileWindow::DecodeWindows(
+    ParseableChunk* parseable_chunk) {
+  if (!parent_) {
+    LOG(DFATAL) << "Internal error: VCDiffDeltaFileWindow::DecodeWindows() "
+                   "called before VCDiffDeltaFileWindow::Init()" << LOG_ENDL;
+    return RESULT_ERROR;
+  }
+  while (!parseable_chunk->Empty()) {
+    if (!found_header_) {
+      switch (ReadHeader(parseable_chunk)) {
+        case RESULT_END_OF_DATA:
+          return RESULT_END_OF_DATA;
+        case RESULT_ERROR:
+          return RESULT_ERROR;
+        default:
+          // Reset address cache between windows (RFC section 5.1)
+          if (!parent_->addr_cache()->Init()) {
+            LOG(DFATAL) << "Error initializing address cache" << LOG_ENDL;
+            return RESULT_ERROR;
+          }
+      }
+    } else {
+      // We are resuming a window that was partially decoded before a
+      // RESULT_END_OF_DATA was returned.  This can only happen on the first
+      // loop iteration, and only if the interleaved format is enabled and used.
+      if (!IsInterleaved()) {
+        LOG(DFATAL) << "Internal error: Resumed decoding of a delta file window"
+                       " when interleaved format is not being used" << LOG_ENDL;
+        return RESULT_ERROR;
+      }
+      UpdateInterleavedSectionPointers(parseable_chunk->UnparsedData(),
+                                       parseable_chunk->End());
+      reader_.UpdatePointers(instructions_and_sizes_.UnparsedDataAddr(),
+                             instructions_and_sizes_.End());
+    }
+    switch (DecodeBody(parseable_chunk)) {
+      case RESULT_END_OF_DATA:
+        if (MoreDataExpected()) {
+          return RESULT_END_OF_DATA;
+        } else {
+          LOG(ERROR) << "End of data reached while decoding VCDIFF delta file"
+                     << LOG_ENDL;
+          // fall through to RESULT_ERROR case
+        }
+      case RESULT_ERROR:
+        return RESULT_ERROR;
+      default:
+        break;  // DecodeBody succeeded
+    }
+    AppendAnnotatedOutput(parent_->annotated_output());
+    // Get ready to read a new delta window
+    Reset();
+    if (parent_->MetTargetByteLimit()) {
+      // Found exactly the length expected.  Stop decoding.
+      return RESULT_SUCCESS;
+    }
+  }
+  return RESULT_SUCCESS;
+}
+
+// *** Methods for VCDiffStreamingDecoder
+
+VCDiffStreamingDecoder::VCDiffStreamingDecoder()
+: impl_(new VCDiffStreamingDecoderImpl) { }
+
+VCDiffStreamingDecoder::~VCDiffStreamingDecoder() { delete impl_; }
+
+void VCDiffStreamingDecoder::StartDecoding(const char* source, size_t len) {
+  impl_->StartDecoding(source, len);
+}
+
+bool VCDiffStreamingDecoder::DecodeChunkToInterface(
+    const char* data,
+    size_t len,
+    OutputStringInterface* output_string) {
+  return impl_->DecodeChunk(data, len, output_string);
+}
+
+bool VCDiffStreamingDecoder::FinishDecoding() {
+  return impl_->FinishDecoding();
+}
+
+void VCDiffStreamingDecoder::EnableAnnotatedOutput() {
+  impl_->EnableAnnotatedOutput();
+}
+
+void VCDiffStreamingDecoder::DisableAnnotatedOutput() {
+  impl_->DisableAnnotatedOutput();
+}
+
+void VCDiffStreamingDecoder::GetAnnotatedOutputToInterface(
+    OutputStringInterface* annotated_output) {
+  impl_->GetAnnotatedOutput(annotated_output);
+}
+
+bool VCDiffDecoder::DecodeToInterface(const char* dictionary_ptr,
+                                      size_t dictionary_size,
+                                      const string& encoding,
+                                      OutputStringInterface* target) {
+  target->clear();
+  decoder_.StartDecoding(dictionary_ptr, dictionary_size);
+  if (!decoder_.DecodeChunkToInterface(encoding.data(),
+                                       encoding.size(),
+                                       target)) {
+    return false;
+  }
+  return decoder_.FinishDecoding();
+}
+
+}  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdecoder_test.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdecoder_test.cc
new file mode 100644
index 0000000..dbf0f15
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdecoder_test.cc
@@ -0,0 +1,4436 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <config.h>
+#include "google/vcdecoder.h"
+#include <cstdlib>  // free, posix_memalign
+#include <cstring>  // memcpy
+#include <string>
+#include "checksum.h"
+#include "codetable.h"
+#include "testing.h"
+#include "varint_bigendian.h"
+#include "vcdiff_defs.h"
+
+#ifdef HAVE_MALLOC_H
+#include <malloc.h>
+#endif  // HAVE_MALLOC_H
+
+#ifdef HAVE_SYS_MMAN_H
+#define _XOPEN_SOURCE 600  // posix_memalign
+#include <sys/mman.h>  // mprotect
+#endif  // HAVE_SYS_MMAN_H
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>  // getpagesize
+#endif  // HAVE_UNISTD_H
+
+namespace open_vcdiff {
+namespace {
+
+using std::string;
+
+// A base class used for all the decoder tests.  Most tests use the same
+// dictionary and target and construct the delta file in the same way.
+// Those elements are provided as string members and can be modified or
+// overwritten by each specific decoder test as needed.
+class VCDiffDecoderTest : public testing::Test {
+ protected:
+  static const char kStandardFileHeader[];
+  static const char kInterleavedFileHeader[];
+  static const char kDictionary[];
+  static const char kExpectedTarget[];
+  static const char kExpectedAnnotatedTarget[];
+
+  VCDiffDecoderTest();
+
+  virtual ~VCDiffDecoderTest() {}
+
+  virtual void SetUp();
+
+  // This function is called by SetUp().  It populates delta_file_ with the
+  // concatenated delta file header, delta window header, and delta window
+  // body, plus (if UseChecksum() is true) the corresponding checksum.
+  // It can be called again by a test that has modified the contents of
+  // delta_file_ and needs to restore them to their original state.
+  virtual void InitializeDeltaFile();
+
+  // This function adds an Adler32 checksum to the delta window header.
+  void AddChecksum(VCDChecksum checksum);
+
+  // This function computes the Adler32 checksum for the expected target
+  // and adds it to the delta window header.
+  void ComputeAndAddChecksum();
+
+  // Write the maximum expressible positive 32-bit VarintBE
+  // (0x7FFFFFFF) at the given offset in the delta window.
+  void WriteMaxVarintAtOffset(int offset, int bytes_to_replace);
+
+  // Write a negative 32-bit VarintBE (0x80000000) at the given offset
+  // in the delta window.
+  void WriteNegativeVarintAtOffset(int offset, int bytes_to_replace);
+
+  // Write a VarintBE that has too many continuation bytes
+  // at the given offset in the delta window.
+  void WriteInvalidVarintAtOffset(int offset, int bytes_to_replace);
+
+  // This function iterates through a list of fuzzers (bit masks used to corrupt
+  // bytes) and through positions in the delta file.  Each time it is called, it
+  // attempts to corrupt a different byte in delta_file_ in a different way.  If
+  // successful, it returns true. Once it exhausts the list of fuzzers and of
+  // byte positions in delta_file_, it returns false.
+  bool FuzzOneByteInDeltaFile();
+
+  // Assuming the length of the given string can be expressed as a VarintBE
+  // of length N, this function returns the byte at position which_byte, where
+  // 0 <= which_byte < N.
+  static char GetByteFromStringLength(const char* s, int which_byte) {
+    char varint_buf[VarintBE<int32_t>::kMaxBytes];
+    VarintBE<int32_t>::Encode(static_cast<int32_t>(strlen(s)), varint_buf);
+    return varint_buf[which_byte];
+  }
+
+  // Assuming the length of the given string can be expressed as a one-byte
+  // VarintBE, this function returns that byte value.
+  static char StringLengthAsByte(const char* s) {
+    return GetByteFromStringLength(s, 0);
+  }
+
+  // Assuming the length of the given string can be expressed as a two-byte
+  // VarintBE, this function returns the first byte of its representation.
+  static char FirstByteOfStringLength(const char* s) {
+    return GetByteFromStringLength(s, 0);
+  }
+
+  // Assuming the length of the given string can be expressed as a two-byte
+  // VarintBE, this function returns the second byte of its representation.
+  static char SecondByteOfStringLength(const char* s) {
+    return GetByteFromStringLength(s, 1);
+  }
+
+  VCDiffStreamingDecoder decoder_;
+
+  // delta_file_ will be populated by InitializeDeltaFile() using the components
+  // delta_file_header_, delta_window_header_, and delta_window_body_.
+  string delta_file_;
+
+  // This string is not populated during setup, but is used to receive the
+  // decoded target file in each test.
+  string output_;
+
+  // Test fixtures that inherit from VCDiffDecoderTest can set these strings in
+  // their constructors to override their default values (which come from
+  // kDictionary, kExpectedTarget, etc.)
+  string dictionary_;
+  string expected_target_;
+  string expected_annotated_target_;
+
+  // The components that will be used to construct delta_file_.
+  string delta_file_header_;
+  string delta_window_header_;
+  string delta_window_body_;
+
+ private:
+  // These two counters are used by FuzzOneByteInDeltaFile() to iterate through
+  // different ways to corrupt the delta file.
+  size_t fuzzer_;
+  size_t fuzzed_byte_position_;
+};
+
+const char VCDiffDecoderTest::kStandardFileHeader[] = {
+    0xD6,  // 'V' | 0x80
+    0xC3,  // 'C' | 0x80
+    0xC4,  // 'D' | 0x80
+    0x00,  // Draft standard version number
+    0x00   // Hdr_Indicator: no custom code table, no compression
+  };
+
+const char VCDiffDecoderTest::kInterleavedFileHeader[] = {
+    0xD6,  // 'V' | 0x80
+    0xC3,  // 'C' | 0x80
+    0xC4,  // 'D' | 0x80
+    'S',   // SDCH version code
+    0x00   // Hdr_Indicator: no custom code table, no compression
+  };
+
+const char VCDiffDecoderTest::kDictionary[] =
+  "\"Just the place for a Snark!\" the Bellman cried,\n"
+  "As he landed his crew with care;\n"
+  "Supporting each man on the top of the tide\n"
+  "By a finger entwined in his hair.\n";
+
+const char VCDiffDecoderTest::kExpectedTarget[] =
+  "\"Just the place for a Snark! I have said it twice:\n"
+  "That alone should encourage the crew.\n"
+  "Just the place for a Snark! I have said it thrice:\n"
+  "What I tell you three times is true.\"\n";
+
+const char VCDiffDecoderTest::kExpectedAnnotatedTarget[] =
+  "<dmatch>\"Just the place for a Snark!</dmatch>"
+  "<literal> I have said it twice:\n"
+  "That alone should encourage the crew.\n</literal>"
+  "<bmatch>Just the place for a Snark! I have said it t</bmatch>"
+  "<literal>hr</literal>"
+  "<bmatch>ice:\n</bmatch>"
+  "<literal>What I te</literal>"
+  "<literal>ll</literal>"
+  "<literal> you three times is true.\"\n</literal>";
+
+VCDiffDecoderTest::VCDiffDecoderTest() : fuzzer_(0), fuzzed_byte_position_(0) {
+  dictionary_ = kDictionary;
+  expected_target_ = kExpectedTarget;
+  expected_annotated_target_ = kExpectedAnnotatedTarget;
+}
+
+void VCDiffDecoderTest::SetUp() {
+  InitializeDeltaFile();
+}
+
+void VCDiffDecoderTest::InitializeDeltaFile() {
+  delta_file_ = delta_file_header_ + delta_window_header_ + delta_window_body_;
+}
+
+void VCDiffDecoderTest::AddChecksum(VCDChecksum checksum) {
+  int32_t checksum_as_int32 = static_cast<int32_t>(checksum);
+  delta_window_header_[0] |= VCD_CHECKSUM;
+  VarintBE<int32_t>::AppendToString(checksum_as_int32, &delta_window_header_);
+  // Adjust delta window size to include checksum.
+  // This method wouldn't work if adding to the length caused the VarintBE
+  // value to spill over into another byte.  Luckily, this test data happens
+  // not to cause such an overflow.
+  delta_window_header_[4] += VarintBE<int32_t>::Length(checksum_as_int32);
+}
+
+void VCDiffDecoderTest::ComputeAndAddChecksum() {
+  AddChecksum(ComputeAdler32(expected_target_.data(),
+                             expected_target_.size()));
+}
+
+// Write the maximum expressible positive 32-bit VarintBE
+// (0x7FFFFFFF) at the given offset in the delta window.
+void VCDiffDecoderTest::WriteMaxVarintAtOffset(int offset,
+                                               int bytes_to_replace) {
+  static const char kMaxVarint[] = { 0x87, 0xFF, 0xFF, 0xFF, 0x7F };
+  delta_file_.replace(delta_file_header_.size() + offset,
+                      bytes_to_replace,
+                      kMaxVarint,
+                      sizeof(kMaxVarint));
+}
+
+// Write a negative 32-bit VarintBE (0x80000000) at the given offset
+// in the delta window.
+void VCDiffDecoderTest::WriteNegativeVarintAtOffset(int offset,
+                                                    int bytes_to_replace) {
+  static const char kNegativeVarint[] = { 0x88, 0x80, 0x80, 0x80, 0x00 };
+  delta_file_.replace(delta_file_header_.size() + offset,
+                      bytes_to_replace,
+                      kNegativeVarint,
+                      sizeof(kNegativeVarint));
+}
+
+// Write a VarintBE that has too many continuation bytes
+// at the given offset in the delta window.
+void VCDiffDecoderTest::WriteInvalidVarintAtOffset(int offset,
+                                                   int bytes_to_replace) {
+  static const char kInvalidVarint[] = { 0x87, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F };
+  delta_file_.replace(delta_file_header_.size() + offset,
+                      bytes_to_replace,
+                      kInvalidVarint,
+                      sizeof(kInvalidVarint));
+}
+
+bool VCDiffDecoderTest::FuzzOneByteInDeltaFile() {
+  static const struct Fuzzer {
+    char _and;
+    char _or;
+    char _xor;
+  } fuzzers[] = {
+    { 0xff, 0x80, 0x00 },
+    { 0xff, 0xff, 0x00 },
+    { 0xff, 0x00, 0x80 },
+    { 0xff, 0x00, 0xff },
+    { 0xff, 0x01, 0x00 },
+    { 0x7f, 0x00, 0x00 },
+  };
+
+  for (; fuzzer_ < (sizeof(fuzzers) / sizeof(fuzzers[0])); ++fuzzer_) {
+    for (; fuzzed_byte_position_ < delta_file_.size();
+         ++fuzzed_byte_position_) {
+      char fuzzed_byte = (((delta_file_[fuzzed_byte_position_]
+                             & fuzzers[fuzzer_]._and)
+                             | fuzzers[fuzzer_]._or)
+                             ^ fuzzers[fuzzer_]._xor);
+      if (fuzzed_byte != delta_file_[fuzzed_byte_position_]) {
+        delta_file_[fuzzed_byte_position_] = fuzzed_byte;
+        ++fuzzed_byte_position_;
+        return true;
+      }
+    }
+    fuzzed_byte_position_ = 0;
+  }
+  return false;
+}
+
+// The "standard" decoder test, which decodes a delta file that uses the
+// standard VCDIFF (RFC 3284) format with no extensions.
+class VCDiffStandardDecoderTest : public VCDiffDecoderTest {
+ protected:
+  VCDiffStandardDecoderTest();
+  virtual ~VCDiffStandardDecoderTest() {}
+
+ private:
+  static const char kWindowHeader[];
+  static const char kWindowBody[];
+};
+
+const char VCDiffStandardDecoderTest::kWindowHeader[] = {
+    VCD_SOURCE,  // Win_Indicator: take source from dictionary
+    FirstByteOfStringLength(kDictionary),  // Source segment size
+    SecondByteOfStringLength(kDictionary),
+    0x00,  // Source segment position: start of dictionary
+    0x79,  // Length of the delta encoding
+    FirstByteOfStringLength(kExpectedTarget),  // Size of the target window
+    SecondByteOfStringLength(kExpectedTarget),
+    0x00,  // Delta_indicator (no compression)
+    0x64,  // length of data for ADDs and RUNs
+    0x0C,  // length of instructions section
+    0x03  // length of addresses for COPYs
+  };
+
+const char VCDiffStandardDecoderTest::kWindowBody[] = {
+    // Data for ADDs: 1st section (length 61)
+    ' ', 'I', ' ', 'h', 'a', 'v', 'e', ' ', 's', 'a', 'i', 'd', ' ',
+    'i', 't', ' ', 't', 'w', 'i', 'c', 'e', ':', '\n',
+    'T', 'h', 'a', 't', ' ',
+    'a', 'l', 'o', 'n', 'e', ' ', 's', 'h', 'o', 'u', 'l', 'd', ' ',
+    'e', 'n', 'c', 'o', 'u', 'r', 'a', 'g', 'e', ' ',
+    't', 'h', 'e', ' ', 'c', 'r', 'e', 'w', '.', '\n',
+    // Data for ADDs: 2nd section (length 2)
+    'h', 'r',
+    // Data for ADDs: 3rd section (length 9)
+    'W', 'h', 'a', 't', ' ',
+    'I', ' ', 't', 'e',
+    // Data for RUN: 4th section (length 1)
+    'l',
+    // Data for ADD: 4th section (length 27)
+    ' ', 'y', 'o', 'u', ' ',
+    't', 'h', 'r', 'e', 'e', ' ', 't', 'i', 'm', 'e', 's', ' ', 'i', 's', ' ',
+    't', 'r', 'u', 'e', '.', '\"', '\n',
+    // Instructions and sizes (length 13)
+    0x13,  // VCD_COPY mode VCD_SELF, size 0
+    0x1C,  // Size of COPY (28)
+    0x01,  // VCD_ADD size 0
+    0x3D,  // Size of ADD (61)
+    0x23,  // VCD_COPY mode VCD_HERE, size 0
+    0x2C,  // Size of COPY (44)
+    0xCB,  // VCD_ADD size 2 + VCD_COPY mode NEAR(1), size 5
+    0x0A,  // VCD_ADD size 9
+    0x00,  // VCD_RUN size 0
+    0x02,  // Size of RUN (2)
+    0x01,  // VCD_ADD size 0
+    0x1B,  // Size of ADD (27)
+    // Addresses for COPYs (length 3)
+    0x00,  // Start of dictionary
+    0x58,  // HERE mode address for 2nd copy (27+61 back from here_address)
+    0x2D   // NEAR(1) mode address for 2nd copy (45 after prior address)
+  };
+
+VCDiffStandardDecoderTest::VCDiffStandardDecoderTest() {
+  delta_file_header_.assign(kStandardFileHeader, sizeof(kStandardFileHeader));
+  delta_window_header_.assign(kWindowHeader, sizeof(kWindowHeader));
+  delta_window_body_.assign(kWindowBody, sizeof(kWindowBody));
+}
+
+TEST_F(VCDiffStandardDecoderTest, DecodeHeaderOnly) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_header_.data(),
+                                   delta_file_header_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, Decode) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+// If we add a checksum to a standard-format delta file (without using format
+// extensions), it will be interpreted as random bytes inserted into the middle
+// of the file.  The decode operation should fail, but where exactly it fails is
+// not easy to predict.
+TEST_F(VCDiffStandardDecoderTest, StandardFormatDoesNotSupportChecksum) {
+  ComputeAndAddChecksum();
+  InitializeDeltaFile();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+// Remove one byte from the length of the chunk to process, and
+// verify that an error is returned for FinishDecoding().
+TEST_F(VCDiffStandardDecoderTest, FinishAfterDecodingPartialWindow) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_.size() - 1,
+                                   &output_));
+  EXPECT_FALSE(decoder_.FinishDecoding());
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTest, FinishAfterDecodingPartialWindowHeader) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_header_.size()
+                                       + delta_window_header_.size() - 1,
+                                   &output_));
+  EXPECT_FALSE(decoder_.FinishDecoding());
+  EXPECT_EQ("", output_);
+}
+
+// Fuzz bits to make sure decoder does not violently crash.
+// This test has no expected behavior except that no crashes should occur.
+// In some cases, changing bits will still decode to the correct target;
+// for example, changing unused bits within a bitfield.
+TEST_F(VCDiffStandardDecoderTest, FuzzBits) {
+  while (FuzzOneByteInDeltaFile()) {
+    decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+    if (decoder_.DecodeChunk(delta_file_.data(),
+                             delta_file_.size(),
+                             &output_)) {
+      decoder_.FinishDecoding();
+    }
+    InitializeDeltaFile();
+    output_.clear();
+  }
+}
+
+TEST_F(VCDiffStandardDecoderTest, CheckAnnotatedOutput) {
+  decoder_.EnableAnnotatedOutput();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  string annotated_output;
+  decoder_.GetAnnotatedOutput(&annotated_output);
+  EXPECT_EQ(expected_annotated_target_, annotated_output);
+}
+
+// Change each element of the delta file window to an erroneous value
+// and make sure it's caught as an error.
+
+TEST_F(VCDiffStandardDecoderTest, WinIndicatorHasBothSourceAndTarget) {
+  delta_file_[delta_file_header_.size()] = VCD_SOURCE + VCD_TARGET;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, OkayToSetUpperBitsOfWinIndicator) {
+  // It is not an error to set any of the other bits in Win_Indicator
+  // besides VCD_SOURCE and VCD_TARGET.
+  delta_file_[delta_file_header_.size()] = 0xFD;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, CopyInstructionsShouldFailIfNoSourceSegment) {
+  // Replace the Win_Indicator and the source size and source offset with a
+  // single 0 byte (a Win_Indicator for a window with no source segment.)
+  delta_window_header_.replace(0, 4, "\0", 1);
+  InitializeDeltaFile();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  // The first COPY instruction should fail, so there should be no output
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, SourceSegmentSizeExceedsDictionarySize) {
+  ++delta_file_[delta_file_header_.size() + 2];  // increment size
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, SourceSegmentSizeMaxInt) {
+  WriteMaxVarintAtOffset(1, 2);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, SourceSegmentSizeNegative) {
+  WriteNegativeVarintAtOffset(1, 2);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, SourceSegmentSizeInvalid) {
+  WriteInvalidVarintAtOffset(1, 2);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, SourceSegmentEndExceedsDictionarySize) {
+  ++delta_file_[delta_file_header_.size() + 3];  // increment start pos
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, SourceSegmentPosMaxInt) {
+  WriteMaxVarintAtOffset(3, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, SourceSegmentPosNegative) {
+  WriteNegativeVarintAtOffset(3, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, SourceSegmentPosInvalid) {
+  WriteInvalidVarintAtOffset(3, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, DeltaEncodingLengthZero) {
+  delta_file_[delta_file_header_.size() + 4] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, DeltaEncodingLengthTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 4];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, DeltaEncodingLengthTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 4];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, DeltaEncodingLengthMaxInt) {
+  WriteMaxVarintAtOffset(4, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, DeltaEncodingLengthNegative) {
+  WriteNegativeVarintAtOffset(4, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, DeltaEncodingLengthInvalid) {
+  WriteInvalidVarintAtOffset(4, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, TargetWindowSizeZero) {
+  static const char zero_size[] = { 0x00 };
+  delta_file_.replace(delta_file_header_.size() + 5, 2, zero_size, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, TargetWindowSizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 6];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, TargetWindowSizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 6];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, TargetWindowSizeMaxInt) {
+  WriteMaxVarintAtOffset(5, 2);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, TargetWindowSizeNegative) {
+  WriteNegativeVarintAtOffset(5, 2);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, TargetWindowSizeInvalid) {
+  WriteInvalidVarintAtOffset(5, 2);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, OkayToSetUpperBitsOfDeltaIndicator) {
+  delta_file_[delta_file_header_.size() + 7] = 0xF8;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, DataCompressionNotSupported) {
+  delta_file_[delta_file_header_.size() + 7] = 0x01;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, InstructionCompressionNotSupported) {
+  delta_file_[delta_file_header_.size() + 7] = 0x02;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, AddressCompressionNotSupported) {
+  delta_file_[delta_file_header_.size() + 7] = 0x04;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, AddRunDataSizeZero) {
+  delta_file_[delta_file_header_.size() + 8] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, AddRunDataSizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 8];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, AddRunDataSizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 8];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, AddRunDataSizeMaxInt) {
+  WriteMaxVarintAtOffset(8, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, AddRunDataSizeNegative) {
+  WriteNegativeVarintAtOffset(8, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, AddRunDataSizeInvalid) {
+  WriteInvalidVarintAtOffset(8, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, InstructionsSizeZero) {
+  delta_file_[delta_file_header_.size() + 9] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, InstructionsSizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 9];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, InstructionsSizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 9];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, InstructionsSizeMaxInt) {
+  WriteMaxVarintAtOffset(9, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, InstructionsSizeNegative) {
+  WriteNegativeVarintAtOffset(9, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, InstructionsSizeInvalid) {
+  WriteInvalidVarintAtOffset(9, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, CopyAddressSizeZero) {
+  delta_file_[delta_file_header_.size() + 10] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, CopyAddressSizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 10];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, CopyAddressSizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 10];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, CopyAddressSizeMaxInt) {
+  WriteMaxVarintAtOffset(10, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, CopyAddressSizeNegative) {
+  WriteNegativeVarintAtOffset(10, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, CopyAddressSizeInvalid) {
+  WriteInvalidVarintAtOffset(10, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, InstructionsEndEarly) {
+  --delta_file_[delta_file_header_.size() + 9];
+  ++delta_file_[delta_file_header_.size() + 10];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+// From this point on, the tests should also be run against the interleaved
+// format.
+
+TEST_F(VCDiffStandardDecoderTest, CopyMoreThanExpectedTarget) {
+  delta_file_[delta_file_header_.size() + 0x70] =
+      FirstByteOfStringLength(kExpectedTarget);
+  delta_file_[delta_file_header_.size() + 0x71] =
+      SecondByteOfStringLength(kExpectedTarget) + 1;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, CopySizeZero) {
+  delta_file_[delta_file_header_.size() + 0x70] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, CopySizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 0x70];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, CopySizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 0x70];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, CopySizeMaxInt) {
+  WriteMaxVarintAtOffset(0x70, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, CopySizeNegative) {
+  WriteNegativeVarintAtOffset(0x70, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, CopySizeInvalid) {
+  WriteInvalidVarintAtOffset(0x70, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, CopyAddressBeyondHereAddress) {
+  delta_file_[delta_file_header_.size() + 0x7B] =
+      FirstByteOfStringLength(kDictionary);
+  delta_file_[delta_file_header_.size() + 0x7C] =
+      SecondByteOfStringLength(kDictionary);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, CopyAddressMaxInt) {
+  WriteMaxVarintAtOffset(0x7B, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, CopyAddressNegative) {
+  WriteNegativeVarintAtOffset(0x70, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, CopyAddressInvalid) {
+  WriteInvalidVarintAtOffset(0x70, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, AddMoreThanExpectedTarget) {
+  delta_file_[delta_file_header_.size() + 0x72] =
+      FirstByteOfStringLength(kExpectedTarget);
+  delta_file_[delta_file_header_.size() + 0x73] =
+      SecondByteOfStringLength(kExpectedTarget) + 1;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, AddSizeZero) {
+  delta_file_[delta_file_header_.size() + 0x72] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, AddSizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 0x72];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, AddSizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 0x72];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, AddSizeMaxInt) {
+  WriteMaxVarintAtOffset(0x72, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, AddSizeNegative) {
+  WriteNegativeVarintAtOffset(0x72, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, AddSizeInvalid) {
+  WriteInvalidVarintAtOffset(0x72, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, RunMoreThanExpectedTarget) {
+  delta_file_[delta_file_header_.size() + 0x78] =
+      FirstByteOfStringLength(kExpectedTarget);
+  delta_file_[delta_file_header_.size() + 0x79] =
+      SecondByteOfStringLength(kExpectedTarget) + 1;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, RunSizeZero) {
+  delta_file_[delta_file_header_.size() + 0x78] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, RunSizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 0x78];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, RunSizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 0x78];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, RunSizeMaxInt) {
+  WriteMaxVarintAtOffset(0x78, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, RunSizeNegative) {
+  WriteNegativeVarintAtOffset(0x78, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTest, RunSizeInvalid) {
+  WriteInvalidVarintAtOffset(0x78, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+// These are the same tests as for VCDiffStandardDecoderTest, with the added
+// complication that instead of calling DecodeChunk() once with the entire data
+// set, DecodeChunk() is called once for each byte of input.  This is intended
+// to shake out any bugs with rewind and resume while parsing chunked data.
+
+typedef VCDiffStandardDecoderTest VCDiffStandardDecoderTestByteByByte;
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, DecodeHeaderOnly) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_header_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_header_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, Decode) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+// Remove one byte from the length of the chunk to process, and
+// verify that an error is returned for FinishDecoding().
+TEST_F(VCDiffStandardDecoderTestByteByByte, FinishAfterDecodingPartialWindow) {
+  delta_file_.resize(delta_file_.size() - 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_FALSE(decoder_.FinishDecoding());
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte,
+       FinishAfterDecodingPartialWindowHeader) {
+  delta_file_.resize(delta_file_header_.size()
+                       + delta_window_header_.size() - 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_FALSE(decoder_.FinishDecoding());
+  EXPECT_EQ("", output_);
+}
+
+// If we add a checksum to a standard-format delta file (without using format
+// extensions), it will be interpreted as random bytes inserted into the middle
+// of the file.  The decode operation should fail, but where exactly it fails is
+// undefined.
+TEST_F(VCDiffStandardDecoderTestByteByByte,
+       StandardFormatDoesNotSupportChecksum) {
+  ComputeAndAddChecksum();
+  InitializeDeltaFile();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+// Fuzz bits to make sure decoder does not violently crash.
+// This test has no expected behavior except that no crashes should occur.
+// In some cases, changing bits will still decode to the correct target;
+// for example, changing unused bits within a bitfield.
+TEST_F(VCDiffStandardDecoderTestByteByByte, FuzzBits) {
+  while (FuzzOneByteInDeltaFile()) {
+    decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+    bool failed = false;
+    for (size_t i = 0; i < delta_file_.size(); ++i) {
+      if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+        failed = true;
+        break;
+      }
+    }
+    if (!failed) {
+      decoder_.FinishDecoding();
+    }
+    // The decoder should not create more target bytes than were expected.
+    EXPECT_GE(expected_target_.size(), output_.size());
+    InitializeDeltaFile();
+    output_.clear();
+  }
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CheckAnnotatedOutput) {
+  decoder_.EnableAnnotatedOutput();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  string annotated_output;
+  decoder_.GetAnnotatedOutput(&annotated_output);
+  EXPECT_EQ(expected_annotated_target_, annotated_output);
+}
+
+// Change each element of the delta file window to an erroneous value
+// and make sure it's caught as an error.
+
+TEST_F(VCDiffStandardDecoderTestByteByByte,
+       WinIndicatorHasBothSourceAndTarget) {
+  delta_file_[delta_file_header_.size()] = VCD_SOURCE + VCD_TARGET;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(delta_file_header_.size(), i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, OkayToSetUpperBitsOfWinIndicator) {
+  // It is not an error to set any of the other bits in Win_Indicator
+  // besides VCD_SOURCE and VCD_TARGET.
+  delta_file_[delta_file_header_.size()] = 0xFD;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte,
+       CopyInstructionsShouldFailIfNoSourceSegment) {
+  // Replace the Win_Indicator and the source size and source offset with a
+  // single 0 byte (a Win_Indicator for a window with no source segment.)
+  delta_window_header_.replace(0, 4, "\0", 1);
+  InitializeDeltaFile();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // The first COPY instruction should fail.  With the standard format,
+      // it may need to see the whole delta window before knowing that it is
+      // invalid.
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte,
+       SourceSegmentSizeExceedsDictionarySize) {
+  ++delta_file_[delta_file_header_.size() + 2];  // increment size
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the source segment size
+      EXPECT_EQ(delta_file_header_.size() + 2, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, SourceSegmentSizeMaxInt) {
+  WriteMaxVarintAtOffset(1, 2);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the source segment size
+      EXPECT_EQ(delta_file_header_.size() + 5, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, SourceSegmentSizeNegative) {
+  WriteNegativeVarintAtOffset(1, 2);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the source segment size
+      EXPECT_EQ(delta_file_header_.size() + 5, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, SourceSegmentSizeInvalid) {
+  WriteInvalidVarintAtOffset(1, 2);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the source segment size
+      EXPECT_GE(delta_file_header_.size() + 6, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte,
+       SourceSegmentEndExceedsDictionarySize) {
+  ++delta_file_[delta_file_header_.size() + 3];  // increment start pos
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the source segment end
+      EXPECT_EQ(delta_file_header_.size() + 3, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, SourceSegmentPosMaxInt) {
+  WriteMaxVarintAtOffset(3, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the source segment pos
+      EXPECT_EQ(delta_file_header_.size() + 7, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, SourceSegmentPosNegative) {
+  WriteNegativeVarintAtOffset(3, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the source segment pos
+      EXPECT_EQ(delta_file_header_.size() + 7, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, SourceSegmentPosInvalid) {
+  WriteInvalidVarintAtOffset(3, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the source segment pos
+      EXPECT_GE(delta_file_header_.size() + 8, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, DeltaEncodingLengthZero) {
+  delta_file_[delta_file_header_.size() + 4] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the copy address segment size
+      EXPECT_EQ(delta_file_header_.size() + 10, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, DeltaEncodingLengthTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 4];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the copy address segment size
+      EXPECT_EQ(delta_file_header_.size() + 10, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, DeltaEncodingLengthTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 4];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the copy address segment size
+      EXPECT_EQ(delta_file_header_.size() + 10, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, DeltaEncodingLengthMaxInt) {
+  WriteMaxVarintAtOffset(4, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail before finishing the window header
+      EXPECT_GE(delta_file_header_.size() + delta_window_header_.size() + 4,
+                i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, DeltaEncodingLengthNegative) {
+  WriteNegativeVarintAtOffset(4, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the delta encoding length
+      EXPECT_EQ(delta_file_header_.size() + 8, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, DeltaEncodingLengthInvalid) {
+  WriteInvalidVarintAtOffset(4, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the delta encoding length
+      EXPECT_GE(delta_file_header_.size() + 9, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, TargetWindowSizeZero) {
+  static const char zero_size[] = { 0x00 };
+  delta_file_.replace(delta_file_header_.size() + 5, 2, zero_size, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, TargetWindowSizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 6];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, TargetWindowSizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 6];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, TargetWindowSizeMaxInt) {
+  WriteMaxVarintAtOffset(5, 2);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the target window size
+      EXPECT_EQ(delta_file_header_.size() + 9, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, TargetWindowSizeNegative) {
+  WriteNegativeVarintAtOffset(5, 2);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the target window size
+      EXPECT_EQ(delta_file_header_.size() + 9, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, TargetWindowSizeInvalid) {
+  WriteInvalidVarintAtOffset(5, 2);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the target window size
+      EXPECT_GE(delta_file_header_.size() + 10, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte,
+       OkayToSetUpperBitsOfDeltaIndicator) {
+  delta_file_[delta_file_header_.size() + 7] = 0xF8;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, DataCompressionNotSupported) {
+  delta_file_[delta_file_header_.size() + 7] = 0x01;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the delta indicator
+      EXPECT_EQ(delta_file_header_.size() + 7, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte,
+       InstructionCompressionNotSupported) {
+  delta_file_[delta_file_header_.size() + 7] = 0x02;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the delta indicator
+      EXPECT_EQ(delta_file_header_.size() + 7, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, AddressCompressionNotSupported) {
+  delta_file_[delta_file_header_.size() + 7] = 0x04;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the delta indicator
+      EXPECT_EQ(delta_file_header_.size() + 7, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, AddRunDataSizeZero) {
+  delta_file_[delta_file_header_.size() + 8] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the copy address segment size
+      EXPECT_EQ(delta_file_header_.size() + 10, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, AddRunDataSizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 8];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the copy address segment size
+      EXPECT_EQ(delta_file_header_.size() + 10, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, AddRunDataSizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 8];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the copy address segment size
+      EXPECT_EQ(delta_file_header_.size() + 10, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, AddRunDataSizeMaxInt) {
+  WriteMaxVarintAtOffset(8, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail before finishing the window header
+      EXPECT_GE(delta_file_header_.size() + delta_window_header_.size() + 4,
+                i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, AddRunDataSizeNegative) {
+  WriteNegativeVarintAtOffset(8, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the add/run data segment size
+      EXPECT_EQ(delta_file_header_.size() + 12, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, AddRunDataSizeInvalid) {
+  WriteInvalidVarintAtOffset(8, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the add/run data segment size
+      EXPECT_GE(delta_file_header_.size() + 13, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, InstructionsSizeZero) {
+  delta_file_[delta_file_header_.size() + 9] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the copy address segment size
+      EXPECT_EQ(delta_file_header_.size() + 10, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, InstructionsSizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 9];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the copy address segment size
+      EXPECT_EQ(delta_file_header_.size() + 10, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, InstructionsSizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 9];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the copy address segment size
+      EXPECT_EQ(delta_file_header_.size() + 10, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, InstructionsSizeMaxInt) {
+  WriteMaxVarintAtOffset(9, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail before finishing the window header
+      EXPECT_GE(delta_file_header_.size() + delta_window_header_.size() + 4,
+                i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, InstructionsSizeNegative) {
+  WriteNegativeVarintAtOffset(9, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the instructions segment size
+      EXPECT_EQ(delta_file_header_.size() + 13, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, InstructionsSizeInvalid) {
+  WriteInvalidVarintAtOffset(9, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the instructions segment size
+      EXPECT_GE(delta_file_header_.size() + 14, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressSizeZero) {
+  delta_file_[delta_file_header_.size() + 10] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the copy address segment size
+      EXPECT_EQ(delta_file_header_.size() + 10, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressSizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 10];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the copy address segment size
+      EXPECT_EQ(delta_file_header_.size() + 10, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressSizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 10];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the copy address segment size
+      EXPECT_EQ(delta_file_header_.size() + 10, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressSizeMaxInt) {
+  WriteMaxVarintAtOffset(10, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the copy address segment size
+      EXPECT_EQ(delta_file_header_.size() + 14, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressSizeNegative) {
+  WriteNegativeVarintAtOffset(10, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the copy address segment size
+      EXPECT_EQ(delta_file_header_.size() + 14, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressSizeInvalid) {
+  WriteInvalidVarintAtOffset(10, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the copy address segment size
+      EXPECT_GE(delta_file_header_.size() + 15, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, InstructionsEndEarly) {
+  --delta_file_[delta_file_header_.size() + 9];
+  ++delta_file_[delta_file_header_.size() + 10];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+// From this point on, the tests should also be run against the interleaved
+// format.
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CopyMoreThanExpectedTarget) {
+  delta_file_[delta_file_header_.size() + 0x70] =
+      FirstByteOfStringLength(kExpectedTarget);
+  delta_file_[delta_file_header_.size() + 0x71] =
+      SecondByteOfStringLength(kExpectedTarget) + 1;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CopySizeZero) {
+  delta_file_[delta_file_header_.size() + 0x70] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CopySizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 0x70];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CopySizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 0x70];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CopySizeMaxInt) {
+  WriteMaxVarintAtOffset(0x70, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CopySizeNegative) {
+  WriteNegativeVarintAtOffset(0x70, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CopySizeInvalid) {
+  WriteInvalidVarintAtOffset(0x70, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressBeyondHereAddress) {
+  delta_file_[delta_file_header_.size() + 0x7B] =
+      FirstByteOfStringLength(kDictionary);
+  delta_file_[delta_file_header_.size() + 0x7C] =
+      SecondByteOfStringLength(kDictionary);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressMaxInt) {
+  WriteMaxVarintAtOffset(0x7B, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressNegative) {
+  WriteNegativeVarintAtOffset(0x70, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressInvalid) {
+  WriteInvalidVarintAtOffset(0x70, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, AddMoreThanExpectedTarget) {
+  delta_file_[delta_file_header_.size() + 0x72] =
+      FirstByteOfStringLength(kExpectedTarget);
+  delta_file_[delta_file_header_.size() + 0x73] =
+      SecondByteOfStringLength(kExpectedTarget) + 1;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, AddSizeZero) {
+  delta_file_[delta_file_header_.size() + 0x72] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, AddSizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 0x72];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, AddSizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 0x72];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, AddSizeMaxInt) {
+  WriteMaxVarintAtOffset(0x72, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, AddSizeNegative) {
+  WriteNegativeVarintAtOffset(0x72, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, AddSizeInvalid) {
+  WriteInvalidVarintAtOffset(0x72, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, RunMoreThanExpectedTarget) {
+  delta_file_[delta_file_header_.size() + 0x78] =
+      FirstByteOfStringLength(kExpectedTarget);
+  delta_file_[delta_file_header_.size() + 0x79] =
+      SecondByteOfStringLength(kExpectedTarget) + 1;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, RunSizeZero) {
+  delta_file_[delta_file_header_.size() + 0x78] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, RunSizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 0x78];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, RunSizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 0x78];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, RunSizeMaxInt) {
+  WriteMaxVarintAtOffset(0x78, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, RunSizeNegative) {
+  WriteNegativeVarintAtOffset(0x78, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffStandardDecoderTestByteByByte, RunSizeInvalid) {
+  WriteInvalidVarintAtOffset(0x78, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+// The "interleaved" decoder test, which decodes a delta file that uses the
+// SDCH extension of interleaving instructions, addresses, and literal data
+// instead of placing them in three separate sections.
+class VCDiffInterleavedDecoderTest : public VCDiffDecoderTest {
+ protected:
+  VCDiffInterleavedDecoderTest();
+  virtual ~VCDiffInterleavedDecoderTest() {}
+
+ private:
+  static const char kWindowHeader[];
+  static const char kWindowBody[];
+};
+
+const char VCDiffInterleavedDecoderTest::kWindowHeader[] = {
+    VCD_SOURCE,  // Win_Indicator: take source from dictionary
+    FirstByteOfStringLength(kDictionary),  // Source segment size
+    SecondByteOfStringLength(kDictionary),
+    0x00,  // Source segment position: start of dictionary
+    0x79,  // Length of the delta encoding
+    FirstByteOfStringLength(kExpectedTarget),  // Size of the target window
+    SecondByteOfStringLength(kExpectedTarget),
+    0x00,  // Delta_indicator (no compression)
+    0x00,  // length of data for ADDs and RUNs (unused)
+    0x73,  // length of interleaved section
+    0x00  // length of addresses for COPYs (unused)
+  };
+
+const char VCDiffInterleavedDecoderTest::kWindowBody[] = {
+    0x13,  // VCD_COPY mode VCD_SELF, size 0
+    0x1C,  // Size of COPY (28)
+    0x00,  // Address of COPY: Start of dictionary
+    0x01,  // VCD_ADD size 0
+    0x3D,  // Size of ADD (61)
+    // Data for ADD (length 61)
+    ' ', 'I', ' ', 'h', 'a', 'v', 'e', ' ', 's', 'a', 'i', 'd', ' ',
+    'i', 't', ' ', 't', 'w', 'i', 'c', 'e', ':', '\n',
+    'T', 'h', 'a', 't', ' ',
+    'a', 'l', 'o', 'n', 'e', ' ', 's', 'h', 'o', 'u', 'l', 'd', ' ',
+    'e', 'n', 'c', 'o', 'u', 'r', 'a', 'g', 'e', ' ',
+    't', 'h', 'e', ' ', 'c', 'r', 'e', 'w', '.', '\n',
+    0x23,  // VCD_COPY mode VCD_HERE, size 0
+    0x2C,  // Size of COPY (44)
+    0x58,  // HERE mode address (27+61 back from here_address)
+    0xCB,  // VCD_ADD size 2 + VCD_COPY mode NEAR(1), size 5
+    // Data for ADDs: 2nd section (length 2)
+    'h', 'r',
+    0x2D,  // NEAR(1) mode address (45 after prior address)
+    0x0A,  // VCD_ADD size 9
+    // Data for ADDs: 3rd section (length 9)
+    'W', 'h', 'a', 't', ' ',
+    'I', ' ', 't', 'e',
+    0x00,  // VCD_RUN size 0
+    0x02,  // Size of RUN (2)
+    // Data for RUN: 4th section (length 1)
+    'l',
+    0x01,  // VCD_ADD size 0
+    0x1B,  // Size of ADD (27)
+    // Data for ADD: 4th section (length 27)
+    ' ', 'y', 'o', 'u', ' ',
+    't', 'h', 'r', 'e', 'e', ' ', 't', 'i', 'm', 'e', 's', ' ', 'i', 's', ' ',
+    't', 'r', 'u', 'e', '.', '\"', '\n'
+  };
+
+VCDiffInterleavedDecoderTest::VCDiffInterleavedDecoderTest() {
+  delta_file_header_.assign(kInterleavedFileHeader,
+                            sizeof(kInterleavedFileHeader));
+  delta_window_header_.assign(kWindowHeader, sizeof(kWindowHeader));
+  delta_window_body_.assign(kWindowBody, sizeof(kWindowBody));
+}
+
+// Test headers, valid and invalid.
+
+TEST_F(VCDiffInterleavedDecoderTest, DecodeHeaderOnly) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_header_.data(),
+                                   delta_file_header_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, PartialHeaderNotEnough) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_header_.data(),
+                                   delta_file_header_.size() - 2,
+                                   &output_));
+  EXPECT_FALSE(decoder_.FinishDecoding());
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, BadMagicNumber) {
+  delta_file_[1] = 'Q' | 0x80;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, BadVersionNumber) {
+  delta_file_[3] = 0x01;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, SecondaryCompressionNotSupported) {
+  delta_file_[4] = 0x01;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, Decode) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, DecodeWithChecksum) {
+  ComputeAndAddChecksum();
+  InitializeDeltaFile();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, ChecksumDoesNotMatch) {
+  AddChecksum(0xBADBAD);
+  InitializeDeltaFile();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+// Remove one byte from the length of the chunk to process, and
+// verify that an error is returned for FinishDecoding().
+TEST_F(VCDiffInterleavedDecoderTest, FinishAfterDecodingPartialWindow) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_.size() - 1,
+                                   &output_));
+  EXPECT_FALSE(decoder_.FinishDecoding());
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, FinishAfterDecodingPartialWindowHeader) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_header_.size()
+                                       + delta_window_header_.size() - 1,
+                                   &output_));
+  EXPECT_FALSE(decoder_.FinishDecoding());
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+// Fuzz bits to make sure decoder does not violently crash.
+// This test has no expected behavior except that no crashes should occur.
+// In some cases, changing bits will still decode to the correct target;
+// for example, changing unused bits within a bitfield.
+TEST_F(VCDiffInterleavedDecoderTest, FuzzBits) {
+  while (FuzzOneByteInDeltaFile()) {
+    decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+    if (decoder_.DecodeChunk(delta_file_.data(),
+                             delta_file_.size(),
+                             &output_)) {
+      decoder_.FinishDecoding();
+    }
+    InitializeDeltaFile();
+    output_.clear();
+  }
+}
+
+// If a checksum is present, then fuzzing any of the bits may produce an error,
+// but it should not result in an incorrect target being produced without
+// an error.
+TEST_F(VCDiffInterleavedDecoderTest, FuzzBitsWithChecksum) {
+  ComputeAndAddChecksum();
+  InitializeDeltaFile();
+  while (FuzzOneByteInDeltaFile()) {
+    decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+    if (decoder_.DecodeChunk(delta_file_.data(),
+                             delta_file_.size(),
+                             &output_)) {
+      if (decoder_.FinishDecoding()) {
+        // Decoding succeeded.  Make sure the correct target was produced.
+        EXPECT_EQ(expected_target_, output_);
+      }
+    } else {
+      EXPECT_EQ("", output_);
+    }
+    InitializeDeltaFile();
+    output_.clear();
+  }
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, CheckAnnotatedOutput) {
+  decoder_.EnableAnnotatedOutput();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  string annotated_output;
+  decoder_.GetAnnotatedOutput(&annotated_output);
+  EXPECT_EQ(expected_annotated_target_, annotated_output);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, CopyMoreThanExpectedTarget) {
+  delta_file_[delta_file_header_.size() + 0x0C] =
+      FirstByteOfStringLength(kExpectedTarget);
+  delta_file_[delta_file_header_.size() + 0x0D] =
+      SecondByteOfStringLength(kExpectedTarget) + 1;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, CopySizeZero) {
+  delta_file_[delta_file_header_.size() + 0x0C] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, CopySizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 0x0C];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, CopySizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 0x0C];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, CopySizeMaxInt) {
+  WriteMaxVarintAtOffset(0x0C, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, CopySizeNegative) {
+  WriteNegativeVarintAtOffset(0x0C, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, CopySizeInvalid) {
+  WriteInvalidVarintAtOffset(0x0C, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, CopyAddressBeyondHereAddress) {
+  delta_file_[delta_file_header_.size() + 0x0D] =
+      FirstByteOfStringLength(kDictionary);
+  delta_file_[delta_file_header_.size() + 0x0E] =
+      SecondByteOfStringLength(kDictionary);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, CopyAddressMaxInt) {
+  WriteMaxVarintAtOffset(0x0D, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, CopyAddressNegative) {
+  WriteNegativeVarintAtOffset(0x0D, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, CopyAddressInvalid) {
+  WriteInvalidVarintAtOffset(0x0D, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, AddMoreThanExpectedTarget) {
+  delta_file_[delta_file_header_.size() + 0x0F] =
+      FirstByteOfStringLength(kExpectedTarget);
+  delta_file_[delta_file_header_.size() + 0x10] =
+      SecondByteOfStringLength(kExpectedTarget) + 1;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, AddSizeZero) {
+  delta_file_[delta_file_header_.size() + 0x0F] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, AddSizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 0x0F];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, AddSizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 0x0F];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, AddSizeMaxInt) {
+  WriteMaxVarintAtOffset(0x0F, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, AddSizeNegative) {
+  WriteNegativeVarintAtOffset(0x0F, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, AddSizeInvalid) {
+  WriteInvalidVarintAtOffset(0x0F, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, RunMoreThanExpectedTarget) {
+  delta_file_[delta_file_header_.size() + 0x5F] =
+      FirstByteOfStringLength(kExpectedTarget);
+  delta_file_[delta_file_header_.size() + 0x60] =
+      SecondByteOfStringLength(kExpectedTarget) + 1;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, RunSizeZero) {
+  delta_file_[delta_file_header_.size() + 0x5F] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, RunSizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 0x5F];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, RunSizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 0x5F];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, RunSizeMaxInt) {
+  WriteMaxVarintAtOffset(0x5F, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, RunSizeNegative) {
+  WriteNegativeVarintAtOffset(0x5F, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, RunSizeInvalid) {
+  WriteInvalidVarintAtOffset(0x5F, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+#if defined(HAVE_MPROTECT) && \
+   (defined(HAVE_MEMALIGN) || defined(HAVE_POSIX_MEMALIGN))
+TEST_F(VCDiffInterleavedDecoderTest, ShouldNotReadPastEndOfBuffer) {
+  // Allocate two memory pages.
+  const int page_size = getpagesize();
+  void* two_pages = NULL;
+#ifdef HAVE_POSIX_MEMALIGN
+  posix_memalign(&two_pages, page_size, 2 * page_size);
+#else  // !HAVE_POSIX_MEMALIGN
+  two_pages = memalign(page_size, 2 * page_size);
+#endif  // HAVE_POSIX_MEMALIGN
+  char* const first_page = reinterpret_cast<char*>(two_pages);
+  char* const second_page = first_page + page_size;
+
+  // Place the delta string at the end of the first page.
+  char* delta_with_guard = second_page - delta_file_.size();
+  memcpy(delta_with_guard, delta_file_.data(), delta_file_.size());
+
+  // Make the second page unreadable.
+  mprotect(second_page, page_size, PROT_NONE);
+
+  // Now perform the decode operation, which will cause a segmentation fault
+  // if it reads past the end of the buffer.
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_with_guard,
+                                   delta_file_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+
+  // Undo the mprotect.
+  mprotect(second_page, page_size, PROT_READ|PROT_WRITE);
+  free(two_pages);
+}
+
+TEST_F(VCDiffInterleavedDecoderTest, ShouldNotReadPastBeginningOfBuffer) {
+  // Allocate two memory pages.
+  const int page_size = getpagesize();
+  void* two_pages = NULL;
+#ifdef HAVE_POSIX_MEMALIGN
+  posix_memalign(&two_pages, page_size, 2 * page_size);
+#else  // !HAVE_POSIX_MEMALIGN
+  two_pages = memalign(page_size, 2 * page_size);
+#endif  // HAVE_POSIX_MEMALIGN
+  char* const first_page = reinterpret_cast<char*>(two_pages);
+  char* const second_page = first_page + page_size;
+
+  // Make the first page unreadable.
+  mprotect(first_page, page_size, PROT_NONE);
+
+  // Place the delta string at the beginning of the second page.
+  char* delta_with_guard = second_page;
+  memcpy(delta_with_guard, delta_file_.data(), delta_file_.size());
+
+  // Now perform the decode operation, which will cause a segmentation fault
+  // if it reads past the beginning of the buffer.
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_with_guard,
+                                   delta_file_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+
+  // Undo the mprotect.
+  mprotect(first_page, page_size, PROT_READ|PROT_WRITE);
+  free(two_pages);
+}
+#endif  // HAVE_MPROTECT && (HAVE_MEMALIGN || HAVE_POSIX_MEMALIGN)
+
+// These are the same tests as for VCDiffInterleavedDecoderTest, with the added
+// complication that instead of calling DecodeChunk() once with the entire data
+// set, DecodeChunk() is called once for each byte of input.  This is intended
+// to shake out any bugs with rewind and resume while parsing chunked data.
+
+typedef VCDiffInterleavedDecoderTest VCDiffInterleavedDecoderTestByteByByte;
+
+// Test headers, valid and invalid.
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, DecodeHeaderOnly) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_header_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_header_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, PartialHeaderNotEnough) {
+  delta_file_.resize(delta_file_header_.size() - 2);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_FALSE(decoder_.FinishDecoding());
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, BadMagicNumber) {
+  delta_file_[1] = 'Q' | 0x80;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      // It should fail at the position that was altered
+      EXPECT_EQ(1U, i);
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, BadVersionNumber) {
+  delta_file_[3] = 0x01;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(3U, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte,
+       SecondaryCompressionNotSupported) {
+  delta_file_[4] = 0x01;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(4U, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, Decode) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, DecodeWithChecksum) {
+  ComputeAndAddChecksum();
+  InitializeDeltaFile();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, ChecksumDoesNotMatch) {
+  AddChecksum(0xBADBAD);
+  InitializeDeltaFile();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail after decoding the entire delta file
+      EXPECT_EQ(delta_file_.size() - 1, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+// Fuzz bits to make sure decoder does not violently crash.
+// This test has no expected behavior except that no crashes should occur.
+// In some cases, changing bits will still decode to the correct target;
+// for example, changing unused bits within a bitfield.
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, FuzzBits) {
+  while (FuzzOneByteInDeltaFile()) {
+    decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+    bool failed = false;
+    for (size_t i = 0; i < delta_file_.size(); ++i) {
+      if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+        failed = true;
+        break;
+      }
+    }
+    if (!failed) {
+      decoder_.FinishDecoding();
+    }
+    InitializeDeltaFile();
+    output_.clear();
+  }
+}
+
+// If a checksum is present, then fuzzing any of the bits may produce an error,
+// but it should not result in an incorrect target being produced without
+// an error.
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, FuzzBitsWithChecksum) {
+  ComputeAndAddChecksum();
+  InitializeDeltaFile();
+  while (FuzzOneByteInDeltaFile()) {
+    decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+    bool failed = false;
+    for (size_t i = 0; i < delta_file_.size(); ++i) {
+      if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+        failed = true;
+        break;
+      }
+    }
+    if (!failed) {
+      if (decoder_.FinishDecoding()) {
+        // Decoding succeeded.  Make sure the correct target was produced.
+        EXPECT_EQ(expected_target_, output_);
+      }
+    }
+    // The decoder should not create more target bytes than were expected.
+    EXPECT_GE(expected_target_.size(), output_.size());
+    InitializeDeltaFile();
+    output_.clear();
+  }
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, CheckAnnotatedOutput) {
+  decoder_.EnableAnnotatedOutput();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  string annotated_output;
+  decoder_.GetAnnotatedOutput(&annotated_output);
+  EXPECT_EQ(expected_annotated_target_, annotated_output);
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte,
+       CopyInstructionsShouldFailIfNoSourceSegment) {
+  // Replace the Win_Indicator and the source size and source offset with a
+  // single 0 byte (a Win_Indicator for a window with no source segment.)
+  delta_window_header_.replace(0, 4, "\0", 1);
+  InitializeDeltaFile();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // The first COPY instruction should fail.
+      EXPECT_EQ(delta_file_header_.size() + delta_window_header_.size() + 2, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopyMoreThanExpectedTarget) {
+  delta_file_[delta_file_header_.size() + 0x0C] =
+      FirstByteOfStringLength(kExpectedTarget);
+  delta_file_[delta_file_header_.size() + 0x0D] =
+      SecondByteOfStringLength(kExpectedTarget) + 1;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(delta_file_header_.size() + 0x0D, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+// A COPY instruction with an explicit size of 0 is not illegal according to the
+// standard, although it is inefficient and should not be generated by any
+// reasonable encoder.  Changing the size of a COPY instruction to zero will
+// cause a failure because the generated target window size will not match the
+// expected target size.
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopySizeZero) {
+  delta_file_[delta_file_header_.size() + 0x0C] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopySizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 0x0C];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopySizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 0x0C];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopySizeMaxInt) {
+  WriteMaxVarintAtOffset(0x0C, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(delta_file_header_.size() + 0x10, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopySizeNegative) {
+  WriteNegativeVarintAtOffset(0x0C, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(delta_file_header_.size() + 0x10, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopySizeInvalid) {
+  WriteInvalidVarintAtOffset(0x0C, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(delta_file_header_.size() + 0x10, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopyAddressBeyondHereAddress) {
+  delta_file_[delta_file_header_.size() + 0x0D] =
+      FirstByteOfStringLength(kDictionary);
+  delta_file_[delta_file_header_.size() + 0x0E] =
+      SecondByteOfStringLength(kDictionary);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(delta_file_header_.size() + 0x0E, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopyAddressMaxInt) {
+  WriteMaxVarintAtOffset(0x0D, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(delta_file_header_.size() + 0x11, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopyAddressNegative) {
+  WriteNegativeVarintAtOffset(0x0D, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(delta_file_header_.size() + 0x11, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopyAddressInvalid) {
+  WriteInvalidVarintAtOffset(0x0D, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(delta_file_header_.size() + 0x11, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, AddMoreThanExpectedTarget) {
+  delta_file_[delta_file_header_.size() + 0x0F] =
+      FirstByteOfStringLength(kExpectedTarget);
+  delta_file_[delta_file_header_.size() + 0x10] =
+      SecondByteOfStringLength(kExpectedTarget) + 1;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(delta_file_header_.size() + 0x10, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+// An ADD instruction with an explicit size of 0 is not illegal according to the
+// standard, although it is inefficient and should not be generated by any
+// reasonable encoder.  Changing the size of an ADD instruction to zero will
+// cause a failure because the generated target window size will not match the
+// expected target size.
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, AddSizeZero) {
+  delta_file_[delta_file_header_.size() + 0x0F] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, AddSizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 0x0F];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, AddSizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 0x0F];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, AddSizeMaxInt) {
+  WriteMaxVarintAtOffset(0x0F, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(delta_file_header_.size() + 0x13, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, AddSizeNegative) {
+  WriteNegativeVarintAtOffset(0x0F, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(delta_file_header_.size() + 0x13, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, AddSizeInvalid) {
+  WriteInvalidVarintAtOffset(0x0F, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(delta_file_header_.size() + 0x13, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, RunMoreThanExpectedTarget) {
+  delta_file_[delta_file_header_.size() + 0x5F] =
+      FirstByteOfStringLength(kExpectedTarget);
+  delta_file_[delta_file_header_.size() + 0x60] =
+      SecondByteOfStringLength(kExpectedTarget) + 1;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(delta_file_header_.size() + 0x60, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+// A RUN instruction with an explicit size of 0 is not illegal according to the
+// standard, although it is inefficient and should not be generated by any
+// reasonable encoder.  Changing the size of a RUN instruction to zero will
+// cause a failure because the generated target window size will not match the
+// expected target size.
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, RunSizeZero) {
+  delta_file_[delta_file_header_.size() + 0x5F] = 0;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, RunSizeTooLargeByOne) {
+  ++delta_file_[delta_file_header_.size() + 0x5F];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, RunSizeTooSmallByOne) {
+  --delta_file_[delta_file_header_.size() + 0x5F];
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, RunSizeMaxInt) {
+  WriteMaxVarintAtOffset(0x5F, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(delta_file_header_.size() + 0x63, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, RunSizeNegative) {
+  WriteNegativeVarintAtOffset(0x5F, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(delta_file_header_.size() + 0x63, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+TEST_F(VCDiffInterleavedDecoderTestByteByByte, RunSizeInvalid) {
+  WriteInvalidVarintAtOffset(0x5F, 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      // It should fail at the position that was altered
+      EXPECT_EQ(delta_file_header_.size() + 0x63, i);
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+// Use the interleaved file header with the standard encoding.  Should work.
+class VCDiffDecoderInterleavedAllowedButNotUsed
+    : public VCDiffStandardDecoderTest {
+ public:
+  VCDiffDecoderInterleavedAllowedButNotUsed() {
+    delta_file_header_.assign(kInterleavedFileHeader,
+                              sizeof(kInterleavedFileHeader));
+  }
+  virtual ~VCDiffDecoderInterleavedAllowedButNotUsed() { }
+};
+
+TEST_F(VCDiffDecoderInterleavedAllowedButNotUsed, Decode) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+TEST_F(VCDiffDecoderInterleavedAllowedButNotUsed, DecodeWithChecksum) {
+  ComputeAndAddChecksum();
+  InitializeDeltaFile();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+typedef VCDiffDecoderInterleavedAllowedButNotUsed
+    VCDiffDecoderInterleavedAllowedButNotUsedByteByByte;
+
+TEST_F(VCDiffDecoderInterleavedAllowedButNotUsedByteByByte, Decode) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+TEST_F(VCDiffDecoderInterleavedAllowedButNotUsedByteByByte,
+       DecodeWithChecksum) {
+  ComputeAndAddChecksum();
+  InitializeDeltaFile();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+// Use the standard file header with the interleaved encoding.  Should fail.
+class VCDiffDecoderInterleavedUsedButNotSupported
+    : public VCDiffInterleavedDecoderTest {
+ public:
+  VCDiffDecoderInterleavedUsedButNotSupported() {
+    delta_file_header_.assign(kStandardFileHeader, sizeof(kStandardFileHeader));
+  }
+  virtual ~VCDiffDecoderInterleavedUsedButNotSupported() { }
+};
+
+TEST_F(VCDiffDecoderInterleavedUsedButNotSupported, DecodeShouldFail) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                    delta_file_.size(),
+                                    &output_));
+  EXPECT_EQ("", output_);
+}
+
+TEST_F(VCDiffDecoderInterleavedUsedButNotSupported,
+       DecodeByteByByteShouldFail) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  bool failed = false;
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
+      failed = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(failed);
+  // The decoder should not create more target bytes than were expected.
+  EXPECT_GE(expected_target_.size(), output_.size());
+}
+
+// Divides up the standard encoding into eight separate delta file windows.
+// Each delta instruction appears in its own window.
+class VCDiffStandardWindowDecoderTest : public VCDiffDecoderTest {
+ protected:
+  VCDiffStandardWindowDecoderTest();
+  virtual ~VCDiffStandardWindowDecoderTest() {}
+
+ private:
+  static const char kExpectedAnnotatedTarget[];
+  static const char kWindowBody[];
+};
+
+const char VCDiffStandardWindowDecoderTest::kWindowBody[] = {
+// Window 1:
+    VCD_SOURCE,  // Win_Indicator: take source from dictionary
+    FirstByteOfStringLength(kDictionary),  // Source segment size
+    SecondByteOfStringLength(kDictionary),
+    0x00,  // Source segment position: start of dictionary
+    0x08,  // Length of the delta encoding
+    0x1C,  // Size of the target window (28)
+    0x00,  // Delta_indicator (no compression)
+    0x00,  // length of data for ADDs and RUNs
+    0x02,  // length of instructions section
+    0x01,  // length of addresses for COPYs
+    // No data for ADDs and RUNs
+    // Instructions and sizes (length 2)
+    0x13,  // VCD_COPY mode VCD_SELF, size 0
+    0x1C,  // Size of COPY (28)
+    // Addresses for COPYs (length 1)
+    0x00,  // Start of dictionary
+// Window 2:
+    0x00,  // Win_Indicator: No source segment (ADD only)
+    0x44,  // Length of the delta encoding
+    0x3D,  // Size of the target window (61)
+    0x00,  // Delta_indicator (no compression)
+    0x3D,  // length of data for ADDs and RUNs
+    0x02,  // length of instructions section
+    0x00,  // length of addresses for COPYs
+    // Data for ADD (length 61)
+    ' ', 'I', ' ', 'h', 'a', 'v', 'e', ' ', 's', 'a', 'i', 'd', ' ',
+    'i', 't', ' ', 't', 'w', 'i', 'c', 'e', ':', '\n',
+    'T', 'h', 'a', 't', ' ',
+    'a', 'l', 'o', 'n', 'e', ' ', 's', 'h', 'o', 'u', 'l', 'd', ' ',
+    'e', 'n', 'c', 'o', 'u', 'r', 'a', 'g', 'e', ' ',
+    't', 'h', 'e', ' ', 'c', 'r', 'e', 'w', '.', '\n',
+    // Instructions and sizes (length 2)
+    0x01,  // VCD_ADD size 0
+    0x3D,  // Size of ADD (61)
+    // No addresses for COPYs
+// Window 3:
+    VCD_TARGET,  // Win_Indicator: take source from decoded data
+    0x59,  // Source segment size: length of data decoded so far
+    0x00,  // Source segment position: start of decoded data
+    0x08,  // Length of the delta encoding
+    0x2C,  // Size of the target window
+    0x00,  // Delta_indicator (no compression)
+    0x00,  // length of data for ADDs and RUNs
+    0x02,  // length of instructions section
+    0x01,  // length of addresses for COPYs
+    // No data for ADDs and RUNs
+    // Instructions and sizes (length 2)
+    0x23,  // VCD_COPY mode VCD_HERE, size 0
+    0x2C,  // Size of COPY (44)
+    // Addresses for COPYs (length 1)
+    0x58,  // HERE mode address (27+61 back from here_address)
+// Window 4:
+    VCD_TARGET,  // Win_Indicator: take source from decoded data
+    0x05,  // Source segment size: only 5 bytes needed for this COPY
+    0x2E,  // Source segment position: offset for COPY
+    0x09,  // Length of the delta encoding
+    0x07,  // Size of the target window
+    0x00,  // Delta_indicator (no compression)
+    0x02,  // length of data for ADDs and RUNs
+    0x01,  // length of instructions section
+    0x01,  // length of addresses for COPYs
+    // Data for ADD (length 2)
+    'h', 'r',
+    // Instructions and sizes (length 1)
+    0xA7,  // VCD_ADD size 2 + VCD_COPY mode SELF size 5
+    // Addresses for COPYs (length 1)
+    0x00,  // SELF mode address (start of source segment)
+// Window 5:
+    0x00,  // Win_Indicator: No source segment (ADD only)
+    0x0F,  // Length of the delta encoding
+    0x09,  // Size of the target window
+    0x00,  // Delta_indicator (no compression)
+    0x09,  // length of data for ADDs and RUNs
+    0x01,  // length of instructions section
+    0x00,  // length of addresses for COPYs
+    // Data for ADD (length 9)
+    'W', 'h', 'a', 't', ' ', 'I', ' ', 't', 'e',
+    // Instructions and sizes (length 1)
+    0x0A,       // VCD_ADD size 9
+    // No addresses for COPYs
+// Window 6:
+    0x00,  // Win_Indicator: No source segment (RUN only)
+    0x08,  // Length of the delta encoding
+    0x02,  // Size of the target window
+    0x00,  // Delta_indicator (no compression)
+    0x01,  // length of data for ADDs and RUNs
+    0x02,  // length of instructions section
+    0x00,  // length of addresses for COPYs
+    // Data for RUN (length 1)
+    'l',
+    // Instructions and sizes (length 2)
+    0x00,  // VCD_RUN size 0
+    0x02,  // Size of RUN (2)
+    // No addresses for COPYs
+// Window 7:
+    0x00,  // Win_Indicator: No source segment (ADD only)
+    0x22,  // Length of the delta encoding
+    0x1B,  // Size of the target window
+    0x00,  // Delta_indicator (no compression)
+    0x1B,  // length of data for ADDs and RUNs
+    0x02,  // length of instructions section
+    0x00,  // length of addresses for COPYs
+    // Data for ADD: 4th section (length 27)
+    ' ', 'y', 'o', 'u', ' ',
+    't', 'h', 'r', 'e', 'e', ' ', 't', 'i', 'm', 'e', 's', ' ', 'i', 's', ' ',
+    't', 'r', 'u', 'e', '.', '\"', '\n',
+    // Instructions and sizes (length 2)
+    0x01,  // VCD_ADD size 0
+    0x1B,  // Size of ADD (27)
+    // No addresses for COPYs
+  };
+
+// The window encoding should produce the same target file as the standard
+// encoding, but the annotated target will be different because some of the
+// <bmatch> tags (copying from the previously decoded data in the current target
+// window) are changed to <dmatch> (copying from the previously decoded data in
+// another target window, which is used as the source window for the current
+// delta window.)
+const char VCDiffStandardWindowDecoderTest::kExpectedAnnotatedTarget[] =
+    "<dmatch>\"Just the place for a Snark!</dmatch>"
+    "<literal> I have said it twice:\n"
+    "That alone should encourage the crew.\n</literal>"
+    "<dmatch>Just the place for a Snark! I have said it t</dmatch>"
+    "<literal>hr</literal>"
+    "<dmatch>ice:\n</dmatch>"
+    "<literal>What I te</literal>"
+    "<literal>ll</literal>"
+    "<literal> you three times is true.\"\n</literal>";
+
+VCDiffStandardWindowDecoderTest::VCDiffStandardWindowDecoderTest() {
+  delta_file_header_.assign(kStandardFileHeader, sizeof(kStandardFileHeader));
+  expected_annotated_target_.assign(kExpectedAnnotatedTarget);
+  delta_window_body_.assign(kWindowBody, sizeof(kWindowBody));
+}
+
+TEST_F(VCDiffStandardWindowDecoderTest, Decode) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+// Bug 1287926: If DecodeChunk() stops in the middle of the window header,
+// and the expected size of the current target window is smaller than the
+// cumulative target bytes decoded so far, an underflow occurs and the decoder
+// tries to allocate ~MAX_INT bytes.
+TEST_F(VCDiffStandardWindowDecoderTest, DecodeBreakInFourthWindowHeader) {
+  // Parse file header + first two windows.
+  const int chunk_1_size = sizeof(kStandardFileHeader) + 83;
+  // Parse third window, plus everything up to "Size of the target window" field
+  // of fourth window, but do not parse complete header of fourth window.
+  const int chunk_2_size = 12 + 5;
+  CHECK_EQ(VCD_TARGET, static_cast<unsigned char>(delta_file_[chunk_1_size]));
+  CHECK_EQ(0x00, static_cast<int>(delta_file_[chunk_1_size + chunk_2_size]));
+  string output_chunk1, output_chunk2, output_chunk3;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[0],
+                                   chunk_1_size,
+                                   &output_chunk1));
+  EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[chunk_1_size],
+                                   chunk_2_size,
+                                   &output_chunk2));
+  EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[chunk_1_size + chunk_2_size],
+                                   delta_file_.size()
+                                       - (chunk_1_size + chunk_2_size),
+                                   &output_chunk3));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_chunk1 + output_chunk2 + output_chunk3);
+}
+
+TEST_F(VCDiffStandardWindowDecoderTest, DecodeInTwoParts) {
+  const size_t delta_file_size = delta_file_.size();
+  for (size_t i = 1; i < delta_file_size; i++) {
+    string output_chunk1, output_chunk2;
+    decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[0],
+                                     i,
+                                     &output_chunk1));
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i],
+                                     delta_file_size - i,
+                                     &output_chunk2));
+    EXPECT_TRUE(decoder_.FinishDecoding());
+    EXPECT_EQ(expected_target_, output_chunk1 + output_chunk2);
+  }
+}
+
+TEST_F(VCDiffStandardWindowDecoderTest, DecodeInThreeParts) {
+  const size_t delta_file_size = delta_file_.size();
+  for (size_t i = 1; i < delta_file_size - 1; i++) {
+    for (size_t j = i + 1; j < delta_file_size; j++) {
+      string output_chunk1, output_chunk2, output_chunk3;
+      decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+      EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[0],
+                                       i,
+                                       &output_chunk1));
+      EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i],
+                                       j - i,
+                                       &output_chunk2));
+      EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[j],
+                                       delta_file_size - j,
+                                       &output_chunk3));
+      EXPECT_TRUE(decoder_.FinishDecoding());
+      EXPECT_EQ(expected_target_,
+                output_chunk1 + output_chunk2 + output_chunk3);
+    }
+  }
+}
+
+typedef VCDiffStandardWindowDecoderTest
+    VCDiffStandardWindowDecoderTestByteByByte;
+TEST_F(VCDiffStandardWindowDecoderTestByteByByte, Decode) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+// Divides up the interleaved encoding into eight separate delta file windows.
+class VCDiffInterleavedWindowDecoderTest
+    : public VCDiffStandardWindowDecoderTest {
+ protected:
+  VCDiffInterleavedWindowDecoderTest();
+  virtual ~VCDiffInterleavedWindowDecoderTest() {}
+ private:
+  static const char kWindowBody[];
+};
+
+const char VCDiffInterleavedWindowDecoderTest::kWindowBody[] = {
+// Window 1:
+    VCD_SOURCE,  // Win_Indicator: take source from dictionary
+    FirstByteOfStringLength(kDictionary),  // Source segment size
+    SecondByteOfStringLength(kDictionary),
+    0x00,  // Source segment position: start of dictionary
+    0x08,  // Length of the delta encoding
+    0x1C,  // Size of the target window (28)
+    0x00,  // Delta_indicator (no compression)
+    0x00,  // length of data for ADDs and RUNs
+    0x03,  // length of instructions section
+    0x00,  // length of addresses for COPYs
+    0x13,  // VCD_COPY mode VCD_SELF, size 0
+    0x1C,  // Size of COPY (28)
+    0x00,  // Start of dictionary
+// Window 2:
+    0x00,  // Win_Indicator: No source segment (ADD only)
+    0x44,  // Length of the delta encoding
+    0x3D,  // Size of the target window (61)
+    0x00,  // Delta_indicator (no compression)
+    0x00,  // length of data for ADDs and RUNs
+    0x3F,  // length of instructions section
+    0x00,  // length of addresses for COPYs
+    0x01,  // VCD_ADD size 0
+    0x3D,  // Size of ADD (61)
+    ' ', 'I', ' ', 'h', 'a', 'v', 'e', ' ', 's', 'a', 'i', 'd', ' ',
+    'i', 't', ' ', 't', 'w', 'i', 'c', 'e', ':', '\n',
+    'T', 'h', 'a', 't', ' ',
+    'a', 'l', 'o', 'n', 'e', ' ', 's', 'h', 'o', 'u', 'l', 'd', ' ',
+    'e', 'n', 'c', 'o', 'u', 'r', 'a', 'g', 'e', ' ',
+    't', 'h', 'e', ' ', 'c', 'r', 'e', 'w', '.', '\n',
+// Window 3:
+    VCD_TARGET,  // Win_Indicator: take source from decoded data
+    0x59,  // Source segment size: length of data decoded so far
+    0x00,  // Source segment position: start of decoded data
+    0x08,  // Length of the delta encoding
+    0x2C,  // Size of the target window
+    0x00,  // Delta_indicator (no compression)
+    0x00,  // length of data for ADDs and RUNs
+    0x03,  // length of instructions section
+    0x00,  // length of addresses for COPYs
+    0x23,  // VCD_COPY mode VCD_HERE, size 0
+    0x2C,  // Size of COPY (44)
+    0x58,  // HERE mode address (27+61 back from here_address)
+// Window 4:
+    VCD_TARGET,  // Win_Indicator: take source from decoded data
+    0x05,  // Source segment size: only 5 bytes needed for this COPY
+    0x2E,  // Source segment position: offset for COPY
+    0x09,  // Length of the delta encoding
+    0x07,  // Size of the target window
+    0x00,  // Delta_indicator (no compression)
+    0x00,  // length of data for ADDs and RUNs
+    0x04,  // length of instructions section
+    0x00,  // length of addresses for COPYs
+    0xA7,  // VCD_ADD size 2 + VCD_COPY mode SELF, size 5
+    'h', 'r',
+    0x00,  // SELF mode address (start of source segment)
+// Window 5:
+    0x00,  // Win_Indicator: No source segment (ADD only)
+    0x0F,  // Length of the delta encoding
+    0x09,  // Size of the target window
+    0x00,  // Delta_indicator (no compression)
+    0x00,  // length of data for ADDs and RUNs
+    0x0A,  // length of instructions section
+    0x00,  // length of addresses for COPYs
+    0x0A,       // VCD_ADD size 9
+    'W', 'h', 'a', 't', ' ', 'I', ' ', 't', 'e',
+// Window 6:
+    0x00,  // Win_Indicator: No source segment (RUN only)
+    0x08,  // Length of the delta encoding
+    0x02,  // Size of the target window
+    0x00,  // Delta_indicator (no compression)
+    0x00,  // length of data for ADDs and RUNs
+    0x03,  // length of instructions section
+    0x00,  // length of addresses for COPYs
+    0x00,  // VCD_RUN size 0
+    0x02,  // Size of RUN (2)
+    'l',
+// Window 7:
+    0x00,  // Win_Indicator: No source segment (ADD only)
+    0x22,  // Length of the delta encoding
+    0x1B,  // Size of the target window
+    0x00,  // Delta_indicator (no compression)
+    0x00,  // length of data for ADDs and RUNs
+    0x1D,  // length of instructions section
+    0x00,  // length of addresses for COPYs
+    0x01,  // VCD_ADD size 0
+    0x1B,  // Size of ADD (27)
+    ' ', 'y', 'o', 'u', ' ',
+    't', 'h', 'r', 'e', 'e', ' ', 't', 'i', 'm', 'e', 's', ' ', 'i', 's', ' ',
+    't', 'r', 'u', 'e', '.', '\"', '\n',
+  };
+
+VCDiffInterleavedWindowDecoderTest::VCDiffInterleavedWindowDecoderTest() {
+  delta_file_header_.assign(kInterleavedFileHeader,
+                            sizeof(kInterleavedFileHeader));
+  // delta_window_header_ is left blank.  All window headers and bodies are
+  // lumped together in delta_window_body_.  This means that AddChecksum()
+  // cannot be used to test the checksum feature.
+  delta_window_body_.assign(kWindowBody, sizeof(kWindowBody));
+}
+
+TEST_F(VCDiffInterleavedWindowDecoderTest, Decode) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+TEST_F(VCDiffInterleavedWindowDecoderTest, DecodeInTwoParts) {
+  const size_t delta_file_size = delta_file_.size();
+  for (size_t i = 1; i < delta_file_size; i++) {
+    string output_chunk1, output_chunk2;
+    decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[0],
+                                     i,
+                                     &output_chunk1));
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i],
+                                     delta_file_size - i,
+                                     &output_chunk2));
+    EXPECT_TRUE(decoder_.FinishDecoding());
+    EXPECT_EQ(expected_target_, output_chunk1 + output_chunk2);
+  }
+}
+
+TEST_F(VCDiffInterleavedWindowDecoderTest, DecodeInThreeParts) {
+  const size_t delta_file_size = delta_file_.size();
+  for (size_t i = 1; i < delta_file_size - 1; i++) {
+    for (size_t j = i + 1; j < delta_file_size; j++) {
+      string output_chunk1, output_chunk2, output_chunk3;
+      decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+      EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[0],
+                                       i,
+                                       &output_chunk1));
+      EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i],
+                                       j - i,
+                                       &output_chunk2));
+      EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[j],
+                                       delta_file_size - j,
+                                       &output_chunk3));
+      EXPECT_TRUE(decoder_.FinishDecoding());
+      EXPECT_EQ(expected_target_,
+                output_chunk1 + output_chunk2 + output_chunk3);
+    }
+  }
+}
+
+typedef VCDiffInterleavedWindowDecoderTest
+    VCDiffInterleavedWindowDecoderTestByteByByte;
+
+TEST_F(VCDiffInterleavedWindowDecoderTestByteByByte, Decode) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+// The original version of VCDiffDecoder did not allow the caller to modify the
+// contents of output_string between calls to DecodeChunk().  That restriction
+// has been removed.  Verify that the same result is still produced if the
+// output string is cleared after each call to DecodeChunk().  Use the window
+// encoding because it refers back to the previously decoded target data, which
+// is the feature that would fail if the restriction still applied.
+//
+TEST_F(VCDiffInterleavedWindowDecoderTest, OutputStringCanBeModified) {
+  string temp_output;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &temp_output));
+    output_.append(temp_output);
+    temp_output.clear();
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+TEST_F(VCDiffInterleavedWindowDecoderTest, OutputStringIsPreserved) {
+  const string previous_data("Previous data");
+  output_ = previous_data;
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(previous_data + expected_target_, output_);
+}
+
+// A decode job that tests the ability to COPY across the boundary between
+// source data and target data.
+class VCDiffStandardCrossDecoderTest : public VCDiffDecoderTest {
+ protected:
+  static const char kExpectedTarget[];
+  static const char kExpectedAnnotatedTarget[];
+  static const char kWindowHeader[];
+  static const char kWindowBody[];
+
+  VCDiffStandardCrossDecoderTest();
+  virtual ~VCDiffStandardCrossDecoderTest() {}
+};
+
+const char VCDiffStandardCrossDecoderTest::kWindowHeader[] = {
+    VCD_SOURCE,  // Win_Indicator: take source from dictionary
+    FirstByteOfStringLength(kDictionary),  // Source segment size
+    SecondByteOfStringLength(kDictionary),
+    0x00,  // Source segment position: start of dictionary
+    0x15,  // Length of the delta encoding
+    StringLengthAsByte(kExpectedTarget),  // Size of the target window
+    0x00,  // Delta_indicator (no compression)
+    0x07,  // length of data for ADDs and RUNs
+    0x06,  // length of instructions section
+    0x03   // length of addresses for COPYs
+  };
+
+const char VCDiffStandardCrossDecoderTest::kWindowBody[] = {
+    // Data for ADD (length 7)
+    'S', 'p', 'i', 'd', 'e', 'r', 's',
+    // Instructions and sizes (length 6)
+    0x01,  // VCD_ADD size 0
+    0x07,  // Size of ADD (7)
+    0x23,  // VCD_COPY mode VCD_HERE, size 0
+    0x19,  // Size of COPY (25)
+    0x14,  // VCD_COPY mode VCD_SELF, size 4
+    0x25,  // VCD_COPY mode VCD_HERE, size 5
+    // Addresses for COPYs (length 3)
+    0x15,  // HERE mode address for 1st copy (21 back from here_address)
+    0x06,  // SELF mode address for 2nd copy
+    0x14   // HERE mode address for 3rd copy
+  };
+
+const char VCDiffStandardCrossDecoderTest::kExpectedTarget[] =
+    "Spiders in his hair.\n"
+    "Spiders in the air.\n";
+
+const char VCDiffStandardCrossDecoderTest::kExpectedAnnotatedTarget[] =
+    "<literal>Spiders</literal>"
+    "<dmatch> in his hair.\n</dmatch>"  // crosses source-target boundary
+    "<bmatch>Spiders in </bmatch>"
+    "<dmatch>the </dmatch>"
+    "<bmatch>air.\n</bmatch>";
+
+VCDiffStandardCrossDecoderTest::VCDiffStandardCrossDecoderTest() {
+  delta_file_header_.assign(kStandardFileHeader, sizeof(kStandardFileHeader));
+  delta_window_header_.assign(kWindowHeader, sizeof(kWindowHeader));
+  delta_window_body_.assign(kWindowBody, sizeof(kWindowBody));
+  expected_target_.assign(kExpectedTarget);
+  expected_annotated_target_.assign(kExpectedAnnotatedTarget);
+}
+
+TEST_F(VCDiffStandardCrossDecoderTest, Decode) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+typedef VCDiffStandardCrossDecoderTest VCDiffStandardCrossDecoderTestByteByByte;
+
+TEST_F(VCDiffStandardCrossDecoderTestByteByByte, Decode) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+// The same decode job that tests the ability to COPY across the boundary
+// between source data and target data, but using the interleaved format rather
+// than the standard format.
+class VCDiffInterleavedCrossDecoderTest
+    : public VCDiffStandardCrossDecoderTest {
+ protected:
+  VCDiffInterleavedCrossDecoderTest();
+  virtual ~VCDiffInterleavedCrossDecoderTest() {}
+
+ private:
+  static const char kWindowHeader[];
+  static const char kWindowBody[];
+};
+
+const char VCDiffInterleavedCrossDecoderTest::kWindowHeader[] = {
+    VCD_SOURCE,  // Win_Indicator: take source from dictionary
+    FirstByteOfStringLength(kDictionary),  // Source segment size
+    SecondByteOfStringLength(kDictionary),
+    0x00,  // Source segment position: start of dictionary
+    0x15,  // Length of the delta encoding
+    StringLengthAsByte(kExpectedTarget),  // Size of the target window
+    0x00,  // Delta_indicator (no compression)
+    0x00,  // length of data for ADDs and RUNs
+    0x10,  // length of instructions section
+    0x00,  // length of addresses for COPYs
+  };
+
+const char VCDiffInterleavedCrossDecoderTest::kWindowBody[] = {
+    0x01,  // VCD_ADD size 0
+    0x07,  // Size of ADD (7)
+    // Data for ADD (length 7)
+    'S', 'p', 'i', 'd', 'e', 'r', 's',
+    0x23,  // VCD_COPY mode VCD_HERE, size 0
+    0x19,  // Size of COPY (25)
+    0x15,  // HERE mode address for 1st copy (21 back from here_address)
+    0x14,  // VCD_COPY mode VCD_SELF, size 4
+    0x06,  // SELF mode address for 2nd copy
+    0x25,  // VCD_COPY mode VCD_HERE, size 5
+    0x14   // HERE mode address for 3rd copy
+  };
+
+VCDiffInterleavedCrossDecoderTest::VCDiffInterleavedCrossDecoderTest() {
+  delta_file_header_.assign(kInterleavedFileHeader,
+                            sizeof(kInterleavedFileHeader));
+  delta_window_header_.assign(kWindowHeader, sizeof(kWindowHeader));
+  delta_window_body_.assign(kWindowBody, sizeof(kWindowBody));
+}
+
+TEST_F(VCDiffInterleavedCrossDecoderTest, Decode) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+TEST_F(VCDiffInterleavedCrossDecoderTest, DecodeWithChecksum) {
+  ComputeAndAddChecksum();
+  InitializeDeltaFile();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+typedef VCDiffInterleavedCrossDecoderTest
+    VCDiffInterleavedCrossDecoderTestByteByByte;
+
+TEST_F(VCDiffInterleavedCrossDecoderTestByteByByte, Decode) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+TEST_F(VCDiffInterleavedCrossDecoderTestByteByByte, DecodeWithChecksum) {
+  ComputeAndAddChecksum();
+  InitializeDeltaFile();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+// Test using a custom code table and custom cache sizes with interleaved
+// format.
+class VCDiffCustomCodeTableDecoderTest : public VCDiffInterleavedDecoderTest {
+ protected:
+  static const char kFileHeader[];
+  static const char kWindowHeader[];
+  static const char kWindowBody[];
+  static const char kEncodedCustomCodeTable[];
+
+  VCDiffCustomCodeTableDecoderTest();
+  virtual ~VCDiffCustomCodeTableDecoderTest() {}
+};
+
+const char VCDiffCustomCodeTableDecoderTest::kFileHeader[] = {
+    0xD6,  // 'V' | 0x80
+    0xC3,  // 'C' | 0x80
+    0xC4,  // 'D' | 0x80
+    'S',   // SDCH version code
+    0x02   // Hdr_Indicator: Use custom code table
+  };
+
+// Make a custom code table that includes exactly the instructions we need
+// to encode the first test's data without using any explicit length values.
+// Be careful not to replace any existing opcodes that have size 0,
+// to ensure that the custom code table is valid (can express all possible
+// values of inst (also known as instruction type) and mode with size 0.)
+// This encoding uses interleaved format, which is easier to read.
+//
+// Here are the changes to the standard code table:
+// ADD size 2 (opcode 3) => RUN size 2 (inst1[3] = VCD_RUN)
+// ADD size 16 (opcode 17) => ADD size 27 (size1[17] = 27)
+// ADD size 17 (opcode 18) => ADD size 61 (size1[18] = 61)
+// COPY mode 0 size 18 (opcode 34) => COPY mode 0 size 28 (size1[34] = 28)
+// COPY mode 1 size 18 (opcode 50) => COPY mode 1 size 44 (size1[50] = 44)
+//
+const char VCDiffCustomCodeTableDecoderTest::kEncodedCustomCodeTable[] = {
+    0xD6,  // 'V' | 0x80
+    0xC3,  // 'C' | 0x80
+    0xC4,  // 'D' | 0x80
+    'S',   // SDCH version code
+    0x00,  // Hdr_Indicator: no custom code table, no compression
+    VCD_SOURCE,  // Win_Indicator: take source from dictionary
+    (sizeof(VCDiffCodeTableData) >> 7) | 0x80,  // First byte of table length
+    sizeof(VCDiffCodeTableData) & 0x7F,  // Second byte of table length
+    0x00,  // Source segment position: start of default code table
+    0x1F,  // Length of the delta encoding
+    (sizeof(VCDiffCodeTableData) >> 7) | 0x80,  // First byte of table length
+    sizeof(VCDiffCodeTableData) & 0x7F,  // Second byte of table length
+    0x00,  // Delta_indicator (no compression)
+    0x00,  // length of data for ADDs and RUNs (unused)
+    0x19,  // length of interleaved section
+    0x00,  // length of addresses for COPYs (unused)
+    0x05,  // VCD_ADD size 4
+    // Data for ADD (length 4)
+    VCD_RUN, VCD_ADD, VCD_ADD, VCD_RUN,
+    0x13,  // VCD_COPY mode VCD_SELF size 0
+    0x84,  // Size of copy: upper bits (512 - 4 + 17 = 525)
+    0x0D,  // Size of copy: lower bits
+    0x04,  // Address of COPY
+    0x03,  // VCD_ADD size 2
+    // Data for ADD (length 2)
+    0x1B, 0x3D,
+    0x3F,  // VCD_COPY mode VCD_NEAR(0) size 15
+    0x84,  // Address of copy: upper bits (525 + 2 = 527)
+    0x0F,  // Address of copy: lower bits
+    0x02,  // VCD_ADD size 1
+    // Data for ADD (length 1)
+    0x1C,
+    0x4F,  // VCD_COPY mode VCD_NEAR(1) size 15
+    0x10,  // Address of copy
+    0x02,  // VCD_ADD size 1
+    // Data for ADD (length 1)
+    0x2C,
+    0x53,  // VCD_COPY mode VCD_NEAR(2) size 0
+    0x87,  // Size of copy: upper bits (256 * 4 - 51 = 973)
+    0x4D,  // Size of copy: lower bits
+    0x10   // Address of copy
+  };
+
+// This is similar to VCDiffInterleavedDecoderTest, but uses the custom code
+// table to eliminate the need to explicitly encode instruction sizes.
+// Notice that NEAR(0) mode is used here where NEAR(1) mode was used in
+// VCDiffInterleavedDecoderTest.  This is because the custom code table
+// has the size of the NEAR cache set to 1; only the most recent
+// COPY instruction is available.  This will also be a test of
+// custom cache sizes.
+const char VCDiffCustomCodeTableDecoderTest::kWindowHeader[] = {
+    VCD_SOURCE,  // Win_Indicator: take source from dictionary
+    FirstByteOfStringLength(kDictionary),  // Source segment size
+    SecondByteOfStringLength(kDictionary),
+    0x00,  // Source segment position: start of dictionary
+    0x74,  // Length of the delta encoding
+    FirstByteOfStringLength(kExpectedTarget),  // Size of the target window
+    SecondByteOfStringLength(kExpectedTarget),
+    0x00,  // Delta_indicator (no compression)
+    0x00,  // length of data for ADDs and RUNs (unused)
+    0x6E,  // length of interleaved section
+    0x00   // length of addresses for COPYs (unused)
+  };
+
+const char VCDiffCustomCodeTableDecoderTest::kWindowBody[] = {
+    0x22,  // VCD_COPY mode VCD_SELF, size 28
+    0x00,  // Address of COPY: Start of dictionary
+    0x12,  // VCD_ADD size 61
+    // Data for ADD (length 61)
+    ' ', 'I', ' ', 'h', 'a', 'v', 'e', ' ', 's', 'a', 'i', 'd', ' ',
+    'i', 't', ' ', 't', 'w', 'i', 'c', 'e', ':', '\n',
+    'T', 'h', 'a', 't', ' ',
+    'a', 'l', 'o', 'n', 'e', ' ', 's', 'h', 'o', 'u', 'l', 'd', ' ',
+    'e', 'n', 'c', 'o', 'u', 'r', 'a', 'g', 'e', ' ',
+    't', 'h', 'e', ' ', 'c', 'r', 'e', 'w', '.', '\n',
+    0x32,  // VCD_COPY mode VCD_HERE, size 44
+    0x58,  // HERE mode address (27+61 back from here_address)
+    0xBF,  // VCD_ADD size 2 + VCD_COPY mode NEAR(0), size 5
+    // Data for ADDs: 2nd section (length 2)
+    'h', 'r',
+    0x2D,  // NEAR(0) mode address (45 after prior address)
+    0x0A,  // VCD_ADD size 9
+    // Data for ADDs: 3rd section (length 9)
+    'W', 'h', 'a', 't', ' ',
+    'I', ' ', 't', 'e',
+    0x03,  // VCD_RUN size 2
+    // Data for RUN: 4th section (length 1)
+    'l',
+    0x11,  // VCD_ADD size 27
+    // Data for ADD: 4th section (length 27)
+    ' ', 'y', 'o', 'u', ' ',
+    't', 'h', 'r', 'e', 'e', ' ', 't', 'i', 'm', 'e', 's', ' ', 'i', 's', ' ',
+    't', 'r', 'u', 'e', '.', '\"', '\n'
+  };
+
+VCDiffCustomCodeTableDecoderTest::VCDiffCustomCodeTableDecoderTest() {
+  delta_file_header_.assign(kFileHeader, sizeof(kFileHeader));
+  delta_file_header_.push_back(0x01);  // NEAR cache size (custom)
+  delta_file_header_.push_back(0x06);  // SAME cache size (custom)
+  delta_file_header_.append(kEncodedCustomCodeTable,
+                            sizeof(kEncodedCustomCodeTable));
+  delta_window_header_.assign(kWindowHeader, sizeof(kWindowHeader));
+  delta_window_body_.assign(kWindowBody, sizeof(kWindowBody));
+}
+
+TEST_F(VCDiffCustomCodeTableDecoderTest, CustomCodeTableEncodingMatches) {
+  VCDiffCodeTableData custom_code_table(
+    VCDiffCodeTableData::kDefaultCodeTableData);
+  custom_code_table.inst1[3] = VCD_RUN;
+  custom_code_table.size1[17] = 27;
+  custom_code_table.size1[18] = 61;
+  custom_code_table.size1[34] = 28;
+  custom_code_table.size1[50] = 44;
+
+  decoder_.StartDecoding(
+      reinterpret_cast<const char*>(
+          &VCDiffCodeTableData::kDefaultCodeTableData),
+      sizeof(VCDiffCodeTableData::kDefaultCodeTableData));
+  EXPECT_TRUE(decoder_.DecodeChunk(kEncodedCustomCodeTable,
+                                   sizeof(kEncodedCustomCodeTable),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(sizeof(custom_code_table), output_.size());
+  const VCDiffCodeTableData* decoded_table =
+      reinterpret_cast<const VCDiffCodeTableData*>(output_.data());
+  EXPECT_EQ(VCD_RUN, decoded_table->inst1[0]);
+  EXPECT_EQ(VCD_RUN, decoded_table->inst1[3]);
+  EXPECT_EQ(27, decoded_table->size1[17]);
+  EXPECT_EQ(61, decoded_table->size1[18]);
+  EXPECT_EQ(28, decoded_table->size1[34]);
+  EXPECT_EQ(44, decoded_table->size1[50]);
+  for (int i = 0; i < VCDiffCodeTableData::kCodeTableSize; ++i) {
+    EXPECT_EQ(custom_code_table.inst1[i], decoded_table->inst1[i]);
+    EXPECT_EQ(custom_code_table.inst2[i], decoded_table->inst2[i]);
+    EXPECT_EQ(custom_code_table.size1[i], decoded_table->size1[i]);
+    EXPECT_EQ(custom_code_table.size2[i], decoded_table->size2[i]);
+    EXPECT_EQ(custom_code_table.mode1[i], decoded_table->mode1[i]);
+    EXPECT_EQ(custom_code_table.mode2[i], decoded_table->mode2[i]);
+  }
+}
+
+TEST_F(VCDiffCustomCodeTableDecoderTest, DecodeUsingCustomCodeTable) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
+                                   delta_file_.size(),
+                                   &output_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+TEST_F(VCDiffCustomCodeTableDecoderTest, IncompleteCustomCodeTable) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_file_header_.data(),
+                                   delta_file_header_.size() - 1,
+                                   &output_));
+  EXPECT_FALSE(decoder_.FinishDecoding());
+  EXPECT_EQ("", output_);
+}
+
+typedef VCDiffCustomCodeTableDecoderTest
+    VCDiffCustomCodeTableDecoderTestByteByByte;
+
+TEST_F(VCDiffCustomCodeTableDecoderTestByteByByte, DecodeUsingCustomCodeTable) {
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(expected_target_, output_);
+}
+
+TEST_F(VCDiffCustomCodeTableDecoderTestByteByByte, IncompleteCustomCodeTable) {
+  delta_file_.resize(delta_file_header_.size() - 1);
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  for (size_t i = 0; i < delta_file_.size(); ++i) {
+    EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
+  }
+  EXPECT_FALSE(decoder_.FinishDecoding());
+  EXPECT_EQ("", output_);
+}
+
+#ifdef GTEST_HAS_DEATH_TEST
+typedef VCDiffCustomCodeTableDecoderTest VCDiffCustomCodeTableDecoderDeathTest;
+
+TEST_F(VCDiffCustomCodeTableDecoderDeathTest, BadCustomCacheSizes) {
+  delta_file_header_.assign(kFileHeader, sizeof(kFileHeader));
+  delta_file_header_.push_back(0x81);  // NEAR cache size (top bit)
+  delta_file_header_.push_back(0x10);  // NEAR cache size (custom value 0x90)
+  delta_file_header_.push_back(0x81);  // SAME cache size (top bit)
+  delta_file_header_.push_back(0x10);  // SAME cache size (custom value 0x90)
+  delta_file_header_.append(kEncodedCustomCodeTable,
+                            sizeof(kEncodedCustomCodeTable));
+  InitializeDeltaFile();
+  decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
+  EXPECT_DEBUG_DEATH(EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
+                                                       delta_file_.size(),
+                                                       &output_)),
+                     "cache");
+  EXPECT_EQ("", output_);
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+}  // namespace open_vcdiff
+}  // unnamed namespace
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdiff_defs.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdiff_defs.h
new file mode 100644
index 0000000..ed35f1f
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdiff_defs.h
@@ -0,0 +1,196 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Types and value definitions to support the implementation of RFC 3284 -
+// The VCDIFF Generic Differencing and Compression Data Format.
+// The RFC text can be found at http://www.faqs.org/rfcs/rfc3284.html
+// Many of the definitions below reference sections in that text.
+
+#ifndef OPEN_VCDIFF_VCDIFF_DEFS_H_
+#define OPEN_VCDIFF_VCDIFF_DEFS_H_
+
+#include <config.h>
+#include <stdint.h>             // int32_t
+#include <climits>              // UCHAR_MAX
+
+namespace open_vcdiff {
+
+enum VCDiffResult {
+  RESULT_SUCCESS = 0,
+  // Many functions within open-vcdiff return signed integer types,
+  // and can also return either of these special negative values:
+  //
+  // An error occurred while performing the requested operation.
+  RESULT_ERROR = -1,
+  // The end of available data was reached
+  // before the requested operation could be completed.
+  RESULT_END_OF_DATA = -2
+};
+
+// The delta file header section as described in section 4.1 of the RFC:
+//
+//    "Each delta file starts with a header section organized as below.
+//     Note the convention that square-brackets enclose optional items.
+//
+//           Header1                                  - byte = 0xD6
+//           Header2                                  - byte = 0xC3
+//           Header3                                  - byte = 0xC4
+//           Header4                                  - byte
+//           Hdr_Indicator                            - byte
+//           [Secondary compressor ID]                - byte
+//           [Length of code table data]              - integer
+//           [Code table data]
+//
+//     The first three Header bytes are the ASCII characters 'V', 'C' and
+//     'D' with their most significant bits turned on (in hexadecimal, the
+//     values are 0xD6, 0xC3, and 0xC4).  The fourth Header byte is
+//     currently set to zero.  In the future, it might be used to indicate
+//     the version of Vcdiff."
+//
+typedef struct DeltaFileHeader {
+  unsigned char header1;  // Always 0xD6 ('V' | 0x80)
+  unsigned char header2;  // Always 0xC3 ('C' | 0x80)
+  unsigned char header3;  // Always 0xC4 ('D' | 0x80)
+  unsigned char header4;  // 0x00 for standard format, 'S' if extensions used
+  unsigned char hdr_indicator;
+} DeltaFileHeader;
+
+// The possible values for the Hdr_Indicator field, as described
+// in section 4.1 of the RFC:
+//
+//    "The Hdr_Indicator byte shows if there is any initialization data
+//     required to aid in the reconstruction of data in the Window sections.
+//     This byte MAY have non-zero values for either, both, or neither of
+//     the two bits VCD_DECOMPRESS and VCD_CODETABLE below:
+//
+//         7 6 5 4 3 2 1 0
+//        +-+-+-+-+-+-+-+-+
+//        | | | | | | | | |
+//        +-+-+-+-+-+-+-+-+
+//                     ^ ^
+//                     | |
+//                     | +-- VCD_DECOMPRESS
+//                     +---- VCD_CODETABLE
+//
+//     If bit 0 (VCD_DECOMPRESS) is non-zero, this indicates that a
+//     secondary compressor may have been used to further compress certain
+//     parts of the delta encoding data [...]"
+// [Secondary compressors are not supported by open-vcdiff.]
+//
+//    "If bit 1 (VCD_CODETABLE) is non-zero, this indicates that an
+//     application-defined code table is to be used for decoding the delta
+//     instructions. [...]"
+//
+const unsigned char VCD_DECOMPRESS = 0x01;
+const unsigned char VCD_CODETABLE = 0x02;
+
+// The possible values for the Win_Indicator field, as described
+// in section 4.2 of the RFC:
+//
+//    "Win_Indicator:
+//
+//     This byte is a set of bits, as shown:
+//
+//      7 6 5 4 3 2 1 0
+//     +-+-+-+-+-+-+-+-+
+//     | | | | | | | | |
+//     +-+-+-+-+-+-+-+-+
+//                  ^ ^
+//                  | |
+//                  | +-- VCD_SOURCE
+//                  +---- VCD_TARGET
+//
+//     If bit 0 (VCD_SOURCE) is non-zero, this indicates that a
+//     segment of data from the "source" file was used as the
+//     corresponding source window of data to encode the target
+//     window.  The decoder will use this same source data segment to
+//     decode the target window.
+//
+//     If bit 1 (VCD_TARGET) is non-zero, this indicates that a
+//     segment of data from the "target" file was used as the
+//     corresponding source window of data to encode the target
+//     window.  As above, this same source data segment is used to
+//     decode the target window.
+//
+//     The Win_Indicator byte MUST NOT have more than one of the bits
+//     set (non-zero).  It MAY have none of these bits set."
+//
+const unsigned char VCD_SOURCE = 0x01;
+const unsigned char VCD_TARGET = 0x02;
+// If this flag is set, the delta window includes an Adler32 checksum
+// of the target window data.  Not part of the RFC draft standard.
+const unsigned char VCD_CHECKSUM = 0x04;
+
+// The possible values for the Delta_Indicator field, as described
+// in section 4.3 of the RFC:
+//
+//    "Delta_Indicator:
+//     This byte is a set of bits, as shown:
+//
+//      7 6 5 4 3 2 1 0
+//     +-+-+-+-+-+-+-+-+
+//     | | | | | | | | |
+//     +-+-+-+-+-+-+-+-+
+//                ^ ^ ^
+//                | | |
+//                | | +-- VCD_DATACOMP
+//                | +---- VCD_INSTCOMP
+//                +------ VCD_ADDRCOMP
+//
+//          VCD_DATACOMP:   bit value 1.
+//          VCD_INSTCOMP:   bit value 2.
+//          VCD_ADDRCOMP:   bit value 4.
+//
+//     [...] If the bit VCD_DECOMPRESS (Section 4.1) was on, each of these
+//     sections may have been compressed using the specified secondary
+//     compressor.  The bit positions 0 (VCD_DATACOMP), 1
+//     (VCD_INSTCOMP), and 2 (VCD_ADDRCOMP) respectively indicate, if
+//     non-zero, that the corresponding parts are compressed."
+// [Secondary compressors are not supported, so open-vcdiff decoding will fail
+//  if these bits are not all zero.]
+//
+const unsigned char VCD_DATACOMP = 0x01;
+const unsigned char VCD_INSTCOMP = 0x02;
+const unsigned char VCD_ADDRCOMP = 0x04;
+
+// A COPY address has 32 bits, which places a limit
+// of 2GB on the maximum combined size of the dictionary plus
+// the target window (= the chunk of data to be encoded.)
+typedef int32_t VCDAddress;
+
+// The address modes used for COPY instructions, as defined in
+// section 5.3 of the RFC.
+//
+// The first two modes (0 and 1) are defined as SELF (addressing forward
+// from the beginning of the source window) and HERE (addressing backward
+// from the current position in the source window + previously decoded
+// target data.)
+//
+// After those first two modes, there are a variable number of NEAR modes
+// (which take a recently-used address and add a positive offset to it)
+// and SAME modes (which match a previously-used address using a "hash" of
+// the lowest bits of the address.)  The number of NEAR and SAME modes
+// depends on the defined size of the address cache; since this number is
+// variable, these modes cannot be specified as enum values.
+enum VCDiffModes {
+  VCD_SELF_MODE = 0,
+  VCD_HERE_MODE = 1,
+  VCD_FIRST_NEAR_MODE = 2,
+  VCD_MAX_MODES = UCHAR_MAX + 1  // 256
+};
+
+}  // namespace open_vcdiff
+
+#endif  // OPEN_VCDIFF_VCDIFF_DEFS_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdiff_main.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdiff_main.cc
new file mode 100644
index 0000000..c83c1c6
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdiff_main.cc
@@ -0,0 +1,609 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// A command-line interface to the open-vcdiff library.
+
+#include <config.h>
+#include <cassert>
+#include <cerrno>
+#include <cstdio>
+#include <cstring>  // strerror
+#include <memory>
+#include <string>
+#include <vector>
+#include "google/gflags.h"
+#include "logging.h"
+#include "google/vcdecoder.h"
+#include "google/vcencoder.h"
+
+using std::string;
+using google::GetCommandLineFlagInfoOrDie;
+using google::ShowUsageWithFlagsRestrict;
+
+// The buffer size, which determines the maximum allowable size
+// of a target window, based on how much memory can be allocated.
+// Both of these can be increased (and the default can be decreased)
+// using the --buffersize flag.
+static const size_t kDefaultBufferSize = 1 << 20;  // 1 MB
+static const size_t kMaxBufferSize = 1 << 26;      // 64 MB
+
+// Definitions of command-line flags
+DEFINE_string(dictionary, "",
+              "File containing dictionary data (required)");
+DEFINE_string(target, "",
+              "Target file (default is stdin for encode, stdout for decode");
+DEFINE_string(delta, "",
+              "Encoded delta file (default is stdout for encode, "
+              "stdin for decode");
+DEFINE_uint64(buffersize, kDefaultBufferSize,
+              "Buffer size for reading input file");
+DEFINE_bool(checksum, false,
+            "Include an Adler32 checksum of the target data when encoding");
+DEFINE_bool(interleaved, false, "Use interleaved format");
+DEFINE_bool(stats, false, "Report compression percentage");
+DEFINE_bool(target_matches, false, "Find duplicate strings in target data"
+                                   " as well as dictionary data");
+
+static const char* const kUsageString =
+    " {encode | delta | decode | patch }[ <options> ]\n"
+    "encode or delta: create delta file from dictionary and target file\n"
+    "decode or patch: reconstruct target file from dictionary and delta file";
+
+namespace open_vcdiff {
+
+class VCDiffFileBasedCoder {
+ public:
+  VCDiffFileBasedCoder();
+  ~VCDiffFileBasedCoder();
+
+  // Once the command-line arguments have been parsed, these functions
+  // will use the supplied options to carry out a file-based encode
+  // or decode operation.
+  bool Encode();
+  bool Decode();
+  bool DecodeAndCompare();  // for "vcdiff test"; compare target with original
+
+ private:
+  // Determines the size of the file.  The given file must be an input file
+  // opened for reading only, not an input stream such as stdin.  The function
+  // returns true and populates file_size if successful; otherwise, it returns
+  // false.
+  static bool FileSize(FILE* file, size_t* file_size);
+
+  // Opens a file for incremental reading.  file_name is the name of the file
+  // to be opened.  file_type should be a descriptive name (like "target") for
+  // use in log messages.  If successful, returns true and sets *file to a
+  // valid input file, *buffer to a region of memory allocated using malloc()
+  // (so the caller must release it using free()), and buffer_size to the size
+  // of the buffer, which will not be larger than the size of the file, and
+  // will not be smaller than the --buffersize option.  If the function fails,
+  // it outputs a log message and returns false.
+  bool OpenFileForReading(const string& file_name,
+                          const char* file_type,
+                          FILE** file,
+                          std::vector<char>* buffer);
+
+  // Opens the dictionary file and reads it into a newly allocated buffer.
+  // If successful, returns true and populates dictionary_ with the dictionary
+  // contents; otherwise, returns false.
+  bool OpenDictionary();
+
+  // Opens the input file (the delta or target file) for reading.
+  // Allocates space for the input buffer.  If successful,
+  // input_file_ will be valid and input_buffer_ will be allocated.
+  bool OpenInputFile() {
+    return OpenFileForReading(input_file_name_,
+                              input_file_type_,
+                              &input_file_,
+                              &input_buffer_);
+  }
+
+  // Opens the output file (the target or delta file) for writing.
+  // If successful, output_file_ will be valid.
+  bool OpenOutputFile();
+
+  // Opens the output file (the target file) for comparison against the decoded
+  // output when using "vcdiff test".
+  bool OpenOutputFileForCompare() {
+    return OpenFileForReading(output_file_name_,
+                              output_file_type_,
+                              &output_file_,
+                              &compare_buffer_);
+  }
+
+  // Reads as much input data as possible from the input file
+  // into input_buffer_.  If successful, returns true and sets *bytes_read
+  // to the number of bytes read into input_buffer_.  If an error occurs,
+  // writes an error log message and returns false.
+  bool ReadInput(size_t* bytes_read);
+
+  // Writes the contents of output to output_file_.  If successful, returns
+  // true.  If an error occurs, writes an error log message and returns false.
+  bool WriteOutput(const string& output);
+
+  // Reads a number of bytes from output_file_ equal to the size of output,
+  // and compares to make sure they match the contents of output.  If the bytes
+  // do not match, or if end of file is reached before the expected number of
+  // bytes have been read, or a read error occurs, the function returns false;
+  // otherwise, returns true.
+  bool CompareOutput(const string& output);
+
+  // Dictionary contents.  The entire dictionary file will be read into memory.
+  std::vector<char> dictionary_;
+
+  std::auto_ptr<open_vcdiff::HashedDictionary> hashed_dictionary_;
+
+  // These should be set to either "delta" or "target".  They are only
+  // used in log messages such as "Error opening delta file..."
+  const char* input_file_type_;
+  const char* output_file_type_;
+
+  // The filenames used for input and output.  Will be empty if stdin
+  // or stdout is being used.
+  string input_file_name_;
+  string output_file_name_;
+
+  // stdio-style file handles for the input and output files and the dictionary.
+  // When encoding, input_file_ is the target file and output_file_ is the delta
+  // file; when decoding, the reverse is true.  The dictionary is always read
+  // from a file rather than from standard input.
+  FILE* input_file_;
+  FILE* output_file_;
+
+  // A memory buffer used to load the input file into memory.  If the input
+  // comes from stdin because no input file was specified, then the size of
+  // input_buffer_ will be the value specified by the --buffersize option.
+  // If the input comes from a file, then the buffer will be allocated to match
+  // the file size, if possible.  However, the buffer will not exceed
+  // kMaxBufferSize bytes in length, unless the user specifies the --buffersize
+  // option to override that limit.
+  std::vector<char> input_buffer_;
+
+  // A memory buffer used to load the output file into memory for comparison
+  // if "vcdiff test" is specified.
+  std::vector<char> compare_buffer_;
+
+  // Making these private avoids implicit copy constructor & assignment operator
+  VCDiffFileBasedCoder(const VCDiffFileBasedCoder&);  // NOLINT
+  void operator=(const VCDiffFileBasedCoder&);
+};
+
+inline VCDiffFileBasedCoder::VCDiffFileBasedCoder()
+    : input_file_type_(""),
+      output_file_type_(""),
+      input_file_(NULL),
+      output_file_(NULL) { }
+
+VCDiffFileBasedCoder::~VCDiffFileBasedCoder() {
+  if (input_file_ && (input_file_ != stdin)) {
+    fclose(input_file_);
+    input_file_ = NULL;
+  }
+  if (output_file_ && (output_file_ != stdout)) {
+    fclose(output_file_);
+    output_file_ = NULL;
+  }
+}
+
+bool VCDiffFileBasedCoder::FileSize(FILE* file, size_t* file_size) {
+  long initial_position = ftell(file);
+  if (fseek(file, 0, SEEK_END) != 0) {
+    return false;
+  }
+  *file_size = static_cast<size_t>(ftell(file));
+  if (fseek(file, initial_position, SEEK_SET) != 0) {
+    return false;
+  }
+  return true;
+}
+
+bool VCDiffFileBasedCoder::OpenDictionary() {
+  assert(dictionary_.empty());
+  assert(!FLAGS_dictionary.empty());
+  FILE* dictionary_file = fopen(FLAGS_dictionary.c_str(), "rb");
+  if (!dictionary_file) {
+    LOG(ERROR) << "Error opening dictionary file '" << FLAGS_dictionary
+               << "': " << strerror(errno) << LOG_ENDL;
+    return false;
+  }
+  size_t dictionary_size = 0U;
+  if (!FileSize(dictionary_file, &dictionary_size)) {
+    LOG(ERROR) << "Error finding size of dictionary file '" << FLAGS_dictionary
+               << "': " << strerror(errno) << LOG_ENDL;
+    return false;
+  }
+  dictionary_.resize(dictionary_size);
+  if (fread(&dictionary_[0], 1, dictionary_size, dictionary_file)
+          != dictionary_size) {
+    LOG(ERROR) << "Unable to read dictionary file '" << FLAGS_dictionary
+               << "': " << strerror(errno) << LOG_ENDL;
+    fclose(dictionary_file);
+    dictionary_.clear();
+    return false;
+  }
+  fclose(dictionary_file);
+  return true;
+}
+
+bool VCDiffFileBasedCoder::OpenFileForReading(const string& file_name,
+                                              const char* file_type,
+                                              FILE** file,
+                                              std::vector<char>* buffer) {
+  assert(buffer->empty());
+  size_t buffer_size = 0U;
+  if (!*file && file_name.empty()) {
+    *file = stdin;
+    buffer_size = static_cast<size_t>(FLAGS_buffersize);
+  } else {
+    if (!*file) {
+      *file = fopen(file_name.c_str(), "rb");
+      if (!*file) {
+        LOG(ERROR) << "Error opening " << file_type << " file '"
+                   << file_name << "': " << strerror(errno) << LOG_ENDL;
+        return false;
+      }
+    }
+    size_t file_size = 0U;
+    if (!FileSize(*file, &file_size)) {
+      LOG(ERROR) << "Error finding size of " << file_type << " file '"
+                 << file_name << "': " << strerror(errno) << LOG_ENDL;
+      return false;
+    }
+    buffer_size = kMaxBufferSize;
+    if (FLAGS_buffersize > buffer_size) {
+      buffer_size = static_cast<size_t>(FLAGS_buffersize);
+    }
+    if (file_size < buffer_size) {
+      // Allocate just enough memory to store the entire file
+      buffer_size = file_size;
+    }
+  }
+  buffer->resize(buffer_size);
+  return true;
+}
+
+// Opens the output file for streamed read operations using the
+// standard C I/O library, i.e., fopen(), fwrite(), fclose().
+// No output buffer is allocated because the encoded/decoded output
+// is constructed progressively using a std::string object
+// whose buffer is resized as needed.
+bool VCDiffFileBasedCoder::OpenOutputFile() {
+  if (output_file_name_.empty()) {
+    output_file_ = stdout;
+  } else {
+    output_file_ = fopen(output_file_name_.c_str(), "wb");
+    if (!output_file_) {
+      LOG(ERROR) << "Error opening " << output_file_type_ << " file '"
+                 << output_file_name_
+                 << "': " << strerror(errno) << LOG_ENDL;
+      return false;
+    }
+  }
+  return true;
+}
+
+bool VCDiffFileBasedCoder::ReadInput(size_t* bytes_read) {
+  // Read from file or stdin
+  *bytes_read = fread(&input_buffer_[0], 1, input_buffer_.size(), input_file_);
+  if (ferror(input_file_)) {
+    LOG(ERROR) << "Error reading from " << input_file_type_ << " file '"
+               << input_file_name_
+               << "': " << strerror(errno) << LOG_ENDL;
+    return false;
+  }
+  return true;
+}
+
+bool VCDiffFileBasedCoder::WriteOutput(const string& output) {
+  if (!output.empty()) {
+    // Some new output has been generated and is ready to be written
+    // to the output file or to stdout.
+    fwrite(output.data(), 1, output.size(), output_file_);
+    if (ferror(output_file_)) {
+      LOG(ERROR) << "Error writing " << output.size() << " bytes to "
+                 << output_file_type_ << " file '" << output_file_name_
+                 << "': " << strerror(errno) << LOG_ENDL;
+      return false;
+    }
+  }
+  return true;
+}
+
+bool VCDiffFileBasedCoder::CompareOutput(const string& output) {
+  if (!output.empty()) {
+    size_t output_size = output.size();
+    // Some new output has been generated and is ready to be compared against
+    // the output file.
+    if (output_size > compare_buffer_.size()) {
+      compare_buffer_.resize(output_size);
+    }
+    size_t bytes_read = fread(&compare_buffer_[0],
+                              1,
+                              output_size,
+                              output_file_);
+    if (ferror(output_file_)) {
+      LOG(ERROR) << "Error reading from " << output_file_type_ << " file '"
+                 << output_file_name_ << "': " << strerror(errno) << LOG_ENDL;
+      return false;
+    }
+    if (bytes_read < output_size) {
+      LOG(ERROR) << "Decoded target is longer than original target file"
+                 << LOG_ENDL;
+      return false;
+    }
+    if (output.compare(0, output_size, &compare_buffer_[0], bytes_read) != 0) {
+      LOG(ERROR) << "Original target file does not match decoded target"
+                 << LOG_ENDL;
+      return false;
+    }
+  }
+  return true;
+}
+
+bool VCDiffFileBasedCoder::Encode() {
+  input_file_type_ = "target";
+  input_file_name_ = FLAGS_target;
+  output_file_type_ = "delta";
+  output_file_name_ = FLAGS_delta;
+  if (!OpenDictionary() || !OpenInputFile() || !OpenOutputFile()) {
+    return false;
+  }
+  hashed_dictionary_.reset(
+      new open_vcdiff::HashedDictionary(&dictionary_[0], dictionary_.size()));
+  if (!hashed_dictionary_->Init()) {
+    LOG(ERROR) << "Error initializing hashed dictionary" << LOG_ENDL;
+    return false;
+  }
+  VCDiffFormatExtensionFlags format_flags = open_vcdiff::VCD_STANDARD_FORMAT;
+  if (FLAGS_interleaved) {
+    format_flags |= open_vcdiff::VCD_FORMAT_INTERLEAVED;
+  }
+  if (FLAGS_checksum) {
+    format_flags |= open_vcdiff::VCD_FORMAT_CHECKSUM;
+  }
+  open_vcdiff::VCDiffStreamingEncoder encoder(hashed_dictionary_.get(),
+                                              format_flags,
+                                              FLAGS_target_matches);
+  string output;
+  size_t input_size = 0;
+  size_t output_size = 0;
+  {
+    if (!encoder.StartEncoding(&output)) {
+      LOG(ERROR) << "Error during encoder initialization" << LOG_ENDL;
+      return false;
+    }
+  }
+  do {
+    size_t bytes_read = 0;
+    if (!WriteOutput(output) || !ReadInput(&bytes_read)) {
+      return false;
+    }
+    output_size += output.size();
+    output.clear();
+    if (bytes_read > 0) {
+      input_size += bytes_read;
+      if (!encoder.EncodeChunk(&input_buffer_[0], bytes_read, &output)) {
+        LOG(ERROR) << "Error trying to encode data chunk of length "
+                   << bytes_read << LOG_ENDL;
+        return false;
+      }
+    }
+  } while (!feof(input_file_));
+  encoder.FinishEncoding(&output);
+  if (!WriteOutput(output)) {
+    return false;
+  }
+  output_size += output.size();
+  output.clear();
+  if (FLAGS_stats && (input_size > 0)) {
+    LOG(INFO) << "Original size: " << input_size
+              << "\tCompressed size: " << output_size << " ("
+              << ((static_cast<double>(output_size) / input_size) * 100)
+              << "% of original)" << LOG_ENDL;
+  }
+  return true;
+}
+
+bool VCDiffFileBasedCoder::Decode() {
+  input_file_type_ = "delta";
+  input_file_name_ = FLAGS_delta;
+  output_file_type_ = "target";
+  output_file_name_ = FLAGS_target;
+  if (!OpenDictionary() || !OpenInputFile() || !OpenOutputFile()) {
+    return false;
+  }
+
+  open_vcdiff::VCDiffStreamingDecoder decoder;
+  string output;
+  size_t input_size = 0;
+  size_t output_size = 0;
+  decoder.StartDecoding(&dictionary_[0], dictionary_.size());
+
+  do {
+    size_t bytes_read = 0;
+    if (!ReadInput(&bytes_read)) {
+      return false;
+    }
+    if (bytes_read > 0) {
+      input_size += bytes_read;
+      if (!decoder.DecodeChunk(&input_buffer_[0], bytes_read, &output)) {
+        LOG(ERROR) << "Error trying to decode data chunk of length "
+                   << bytes_read << LOG_ENDL;
+        return false;
+      }
+    }
+    if (!WriteOutput(output)) {
+      return false;
+    }
+    output_size += output.size();
+    output.clear();
+  } while (!feof(input_file_));
+  if (!decoder.FinishDecoding()) {
+    LOG(ERROR) << "Decode error; '" << FLAGS_delta
+               << " may not be a valid VCDIFF delta file" << LOG_ENDL;
+    return false;
+  }
+  if (!WriteOutput(output)) {
+    return false;
+  }
+  output_size += output.size();
+  output.clear();
+  if (FLAGS_stats && (output_size > 0)) {
+    LOG(INFO) << "Decompressed size: " << output_size
+              << "\tCompressed size: " << input_size << " ("
+              << ((static_cast<double>(input_size) / output_size) * 100)
+              << "% of original)" << LOG_ENDL;
+  }
+  return true;
+}
+
+bool VCDiffFileBasedCoder::DecodeAndCompare() {
+  input_file_type_ = "delta";
+  input_file_name_ = FLAGS_delta;
+  output_file_type_ = "target";
+  output_file_name_ = FLAGS_target;
+  if (!OpenDictionary() || !OpenInputFile() || !OpenOutputFileForCompare()) {
+    return false;
+  }
+
+  open_vcdiff::VCDiffStreamingDecoder decoder;
+  string output;
+  size_t input_size = 0;
+  size_t output_size = 0;
+  decoder.StartDecoding(&dictionary_[0], dictionary_.size());
+
+  do {
+    size_t bytes_read = 0;
+    if (!ReadInput(&bytes_read)) {
+      return false;
+    }
+    if (bytes_read > 0) {
+      input_size += bytes_read;
+      if (!decoder.DecodeChunk(&input_buffer_[0], bytes_read, &output)) {
+        LOG(ERROR) << "Error trying to decode data chunk of length "
+                   << bytes_read << LOG_ENDL;
+        return false;
+      }
+    }
+    if (!CompareOutput(output)) {
+      return false;
+    }
+    output_size += output.size();
+    output.clear();
+  } while (!feof(input_file_));
+  if (!decoder.FinishDecoding()) {
+    LOG(ERROR) << "Decode error; '" << FLAGS_delta
+               << " may not be a valid VCDIFF delta file" << LOG_ENDL;
+    return false;
+  }
+  if (!CompareOutput(output)) {
+    return false;
+  }
+  output_size += output.size();
+  output.clear();
+  if (fgetc(output_file_) != EOF) {
+    LOG(ERROR) << "Decoded target is shorter than original target file"
+               << LOG_ENDL;
+    return false;
+  }
+  if (ferror(output_file_)) {
+    LOG(ERROR) << "Error reading end-of-file indicator from target file"
+               << LOG_ENDL;
+    return false;
+  }
+  if (FLAGS_stats && (output_size > 0)) {
+    LOG(INFO) << "Decompressed size: " << output_size
+              << "\tCompressed size: " << input_size << " ("
+              << ((static_cast<double>(input_size) / output_size) * 100)
+              << "% of original)" << LOG_ENDL;
+  }
+  return true;
+}
+
+}  // namespace open_vcdiff
+
+int main(int argc, char** argv) {
+  const char* const command_name = argv[0];
+  google::SetUsageMessage(kUsageString);
+  google::ParseCommandLineFlags(&argc, &argv, true);
+  if (argc != 2) {
+    LOG(ERROR) << command_name << ": Must specify exactly one command option"
+               << LOG_ENDL;
+    ShowUsageWithFlagsRestrict(command_name, "vcdiff");
+    return 1;
+  }
+  const char* const command_option = argv[1];
+  if (FLAGS_dictionary.empty()) {
+    LOG(ERROR) << command_name << " " << command_option
+               << ": Must specify --dictionary <file-name>" << LOG_ENDL;
+    ShowUsageWithFlagsRestrict(command_name, "vcdiff");
+    return 1;
+  }
+  if (!GetCommandLineFlagInfoOrDie("buffersize").is_default &&
+       (FLAGS_buffersize == 0)) {
+    LOG(ERROR) << command_name << ": Option --buffersize cannot be 0"
+               << LOG_ENDL;
+    ShowUsageWithFlagsRestrict(command_name, "vcdiff");
+    return 1;
+  }
+  if ((strcmp(command_option, "encode") == 0) ||
+      (strcmp(command_option, "delta") == 0)) {
+    open_vcdiff::VCDiffFileBasedCoder coder;
+    if (!coder.Encode()) {
+      return 1;
+    }
+    // The destructor for VCDiffFileBasedCoder will clean up the open files
+    // and allocated memory.
+  } else if ((strcmp(command_option, "decode") == 0) ||
+             (strcmp(command_option, "patch") == 0)) {
+    open_vcdiff::VCDiffFileBasedCoder coder;
+    if (!coder.Decode()) {
+      return 1;
+    }
+  } else if ((strcmp(command_option, "test") == 0)) {
+    // "vcdiff test" does not appear in the usage string, but can be
+    // used for debugging.  It encodes, then decodes, then compares the result
+    // with the original target. It expects the same arguments as
+    // "vcdiff encode", with the additional requirement that the --target
+    // and --delta file arguments must be specified, rather than using stdin
+    // or stdout.  It produces a delta file just as for "vcdiff encode".
+    if (FLAGS_target.empty() || FLAGS_delta.empty()) {
+      LOG(ERROR) << command_name
+                 << " test: Must specify both --target <file-name>"
+                    " and --delta <file-name>" << LOG_ENDL;
+      return 1;
+    }
+    const string original_target(FLAGS_target);
+    // Put coder into a separate scope.
+    {
+      open_vcdiff::VCDiffFileBasedCoder coder;
+      if (!coder.Encode()) {
+        return 1;
+      }
+    }
+    {
+      open_vcdiff::VCDiffFileBasedCoder coder;
+      if (!coder.DecodeAndCompare()) {
+        return 1;
+      }
+    }
+  } else {
+    LOG(ERROR) << command_name << ": Unrecognized command option "
+               << command_option << LOG_ENDL;
+    ShowUsageWithFlagsRestrict(command_name, "vcdiff");
+    return 1;
+  }
+  return 0;
+}
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdiffengine.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdiffengine.cc
new file mode 100644
index 0000000..5553b57
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdiffengine.cc
@@ -0,0 +1,228 @@
+// Copyright 2006, 2008 Google Inc.
+// Authors: Chandra Chereddi, Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <config.h>
+#include "vcdiffengine.h"
+#include <stdint.h>  // uint32_t
+#include <string>
+#include "blockhash.h"
+#include "encodetable.h"
+#include "logging.h"
+#include "rolling_hash.h"
+
+namespace open_vcdiff {
+
+using std::string;
+
+VCDiffEngine::~VCDiffEngine() {
+  delete hashed_dictionary_;
+}
+
+bool VCDiffEngine::Init() {
+  if (hashed_dictionary_) {
+    LOG(DFATAL) << "Init() called twice for same VCDiffEngine object"
+                << LOG_ENDL;
+    return false;
+  }
+  hashed_dictionary_ = BlockHash::CreateDictionaryHash(dictionary_.data(),
+                                                       dictionary_size());
+  if (!hashed_dictionary_) {
+    LOG(DFATAL) << "Creation of dictionary hash failed" << LOG_ENDL;
+    return false;
+  }
+  if (!RollingHash<BlockHash::kBlockSize>::Init()) {
+    LOG(DFATAL) << "RollingHash initialization failed" << LOG_ENDL;
+    return false;
+  }
+  return true;
+}
+
+// This helper function tries to find an appropriate match within
+// hashed_dictionary_ for the block starting at the current target position.
+// If target_hash is not NULL, this function will also look for a match
+// within the previously encoded target data.
+//
+// If a match is found, this function will generate an ADD instruction
+// for all unencoded data that precedes the match,
+// and a COPY instruction for the match itself; then it returns
+// the number of bytes processed by both instructions,
+// which is guaranteed to be > 0.
+// If no appropriate match is found, the function returns 0.
+//
+// The first four parameters are input parameters which are passed
+// directly to BlockHash::FindBestMatch; please see that function
+// for a description of their allowable values.
+size_t VCDiffEngine::EncodeCopyForBestMatch(
+    uint32_t hash_value,
+    const char* target_candidate_start,
+    const char* unencoded_target_start,
+    size_t unencoded_target_size,
+    const BlockHash* target_hash,
+    VCDiffCodeTableWriter* coder) const {
+  // When FindBestMatch() comes up with a match for a candidate block,
+  // it will populate best_match with the size, source offset,
+  // and target offset of the match.
+  BlockHash::Match best_match;
+
+  // First look for a match in the dictionary.
+  hashed_dictionary_->FindBestMatch(hash_value,
+                                    target_candidate_start,
+                                    unencoded_target_start,
+                                    unencoded_target_size,
+                                    &best_match);
+  // If target matching is enabled, then see if there is a better match
+  // within the target data that has been encoded so far.
+  if (target_hash) {
+    target_hash->FindBestMatch(hash_value,
+                               target_candidate_start,
+                               unencoded_target_start,
+                               unencoded_target_size,
+                               &best_match);
+  }
+  if (!ShouldGenerateCopyInstructionForMatchOfSize(best_match.size())) {
+    return 0;
+  }
+  if (best_match.target_offset() > 0) {
+    // Create an ADD instruction to encode all target bytes
+    // from the end of the last COPY match, if any, up to
+    // the beginning of this COPY match.
+    coder->Add(unencoded_target_start, best_match.target_offset());
+  }
+  coder->Copy(best_match.source_offset(), best_match.size());
+  return best_match.target_offset()  // ADD size
+       + best_match.size();          // + COPY size
+}
+
+// Once the encoder loop has finished checking for matches in the target data,
+// this function creates an ADD instruction to encode all target bytes
+// from the end of the last COPY match, if any, through the end of
+// the target data.  In the worst case, if no matches were found at all,
+// this function will create one big ADD instruction
+// for the entire buffer of target data.
+inline void VCDiffEngine::AddUnmatchedRemainder(
+    const char* unencoded_target_start,
+    size_t unencoded_target_size,
+    VCDiffCodeTableWriter* coder) const {
+  if (unencoded_target_size > 0) {
+    coder->Add(unencoded_target_start, unencoded_target_size);
+  }
+}
+
+// This helper function tells the coder to finish the encoding and write
+// the results into the output string "diff".
+inline void VCDiffEngine::FinishEncoding(size_t target_size,
+                                         OutputStringInterface* diff,
+                                         VCDiffCodeTableWriter* coder) const {
+  if (target_size != static_cast<size_t>(coder->target_length())) {
+    LOG(DFATAL) << "Internal error in VCDiffEngine::Encode: "
+                   "original target size (" << target_size
+                << ") does not match number of bytes processed ("
+                << coder->target_length() << ")" << LOG_ENDL;
+  }
+  coder->Output(diff);
+}
+
+void VCDiffEngine::Encode(const char* target_data,
+                          size_t target_size,
+                          bool look_for_target_matches,
+                          OutputStringInterface* diff,
+                          VCDiffCodeTableWriter* coder) const {
+  if (!hashed_dictionary_) {
+    LOG(DFATAL) << "Internal error: VCDiffEngine::Encode() "
+                   "called before VCDiffEngine::Init()" << LOG_ENDL;
+    return;
+  }
+  if (target_size == 0) {
+    return;  // Do nothing for empty target
+  }
+  if (!coder->Init(dictionary_size())) {
+    LOG(DFATAL) << "Internal error: "
+                   "Initialization of VCDiffCodeTableWriter failed" << LOG_ENDL;
+    return;
+  }
+  // Special case for really small input
+  if (target_size < static_cast<size_t>(BlockHash::kBlockSize)) {
+    AddUnmatchedRemainder(target_data, target_size, coder);
+    FinishEncoding(target_size, diff, coder);
+    return;
+  }
+  RollingHash<BlockHash::kBlockSize> hasher;
+  BlockHash* target_hash = NULL;
+  if (look_for_target_matches) {
+    // Check matches against previously encoded target data
+    // in this same target window, as well as against the dictionary
+    target_hash = BlockHash::CreateTargetHash(target_data,
+                                              target_size,
+                                              dictionary_size());
+    if (!target_hash) {
+      LOG(ERROR) << "Instantiation of target hash failed" << LOG_ENDL;
+      // Keep going despite the error.  Since target_hash is NULL,
+      // only the source hash will be used to find matches.
+    }
+  }
+  const char* const target_end = target_data + target_size;
+  const char* const start_of_last_block = target_end - BlockHash::kBlockSize;
+  // Offset of next bytes in string to ADD if NOT copied (i.e., not found in
+  // dictionary)
+  const char* next_encode = target_data;
+  // candidate_pos points to the start of the kBlockSize-byte block that may
+  // begin a match with the dictionary or previously encoded target data.
+  const char* candidate_pos = target_data;
+  uint32_t hash_value = hasher.Hash(candidate_pos);
+  while (1) {
+    const size_t bytes_encoded =
+        EncodeCopyForBestMatch(hash_value,
+                               candidate_pos,
+                               next_encode,
+                               (target_end - next_encode),
+                               target_hash,
+                               coder);
+    if (bytes_encoded > 0) {
+      next_encode += bytes_encoded;  // Advance past COPYed data
+      candidate_pos = next_encode;
+      if (candidate_pos > start_of_last_block) {
+        break;  // Reached end of target data
+      }
+      // candidate_pos has jumped ahead by bytes_encoded bytes, so UpdateHash
+      // can't be used to calculate the hash value at its new position.
+      hash_value = hasher.Hash(candidate_pos);
+      if (target_hash) {
+        // Update the target hash for the ADDed and COPYed data
+        target_hash->AddAllBlocksThroughIndex(
+            static_cast<int>(next_encode - target_data));
+      }
+    } else {
+      // No match, or match is too small to be worth a COPY instruction.
+      // Move to the next position in the target data.
+      if ((candidate_pos + 1) > start_of_last_block) {
+        break;  // Reached end of target data
+      }
+      if (target_hash) {
+        target_hash->AddOneIndexHash(
+            static_cast<int>(candidate_pos - target_data),
+            hash_value);
+      }
+      hash_value = hasher.UpdateHash(hash_value,
+                                     candidate_pos[0],
+                                     candidate_pos[BlockHash::kBlockSize]);
+      ++candidate_pos;
+    }
+  }
+  AddUnmatchedRemainder(next_encode, target_end - next_encode, coder);
+  FinishEncoding(target_size, diff, coder);
+  delete target_hash;
+}
+
+}  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdiffengine.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdiffengine.h
new file mode 100644
index 0000000..c6c423f
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdiffengine.h
@@ -0,0 +1,119 @@
+// Copyright 2006 Google Inc.
+// Authors: Sanjay Ghemawat, Jeff Dean, Chandra Chereddi, Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OPEN_VCDIFF_VCDIFFENGINE_H_
+#define OPEN_VCDIFF_VCDIFFENGINE_H_
+
+#include <config.h>
+#include <stdint.h>  // uint32_t
+#include <string>
+
+namespace open_vcdiff {
+
+using std::string;
+
+class BlockHash;
+class OutputStringInterface;
+class VCDiffCodeTableWriter;
+
+// The VCDiffEngine class is used to find the optimal encoding (in terms of
+// COPY and ADD instructions) for a given dictionary and target window.
+// To write the instructions for this encoding, it calls the Copy()
+// and Add() methods of the VCDiffCodeTableWriter object which is passed
+// as an argument to Encode().
+//
+class VCDiffEngine {
+ public:
+  VCDiffEngine(const char* dictionary,
+               size_t dictionary_size)
+      // If dictionary_size == 0, then dictionary could be NULL.  Guard against
+      // using a NULL value.
+      : dictionary_((dictionary_size > 0) ? dictionary : "", dictionary_size),
+        hashed_dictionary_(NULL) { }
+
+  ~VCDiffEngine();
+
+  // Initializes the object before use.
+  // This method must be called after constructing a VCDiffEngine object,
+  // and before any other method may be called.  It should not be called
+  // twice on the same object.
+  // Returns true if initialization succeeded, or false if an error occurred,
+  // in which case no other method except the destructor may then be used
+  // on the object.
+  // The Init() method is the only one allowed to treat hashed_dictionary_
+  // as non-const.
+  bool Init();
+
+  const size_t dictionary_size() const { return dictionary_.size(); }
+
+  // Main worker function.  Finds the best matches between the dictionary
+  // (source) and target data, and uses the coder to write a
+  // delta file window into *diff.
+  // Because it is a const function, many threads
+  // can call Encode() at once for the same VCDiffEngine object.
+  // All thread-specific data will be stored in the coder and diff arguments.
+  //
+  // look_for_target_matches determines whether to look for matches
+  // within the previously encoded target data, or just within the source
+  // (dictionary) data.  Please see vcencoder.h for a full explanation
+  // of this parameter.
+  void Encode(const char* target_data,
+              size_t target_size,
+              bool look_for_target_matches,
+              OutputStringInterface* diff,
+              VCDiffCodeTableWriter* coder) const;
+
+ private:
+  // The minimum size of a string match that is worth putting into
+  // a COPY instruction.  This value is taken from the RFC, which states:
+  // "The choice of the minimum size 4 for COPY instructions in the default
+  //  code table was made from experiments that showed that excluding small
+  //  matches (less than 4 bytes long) improved the compression rates."
+  static const size_t kMinimumMatchSize = 4;
+
+  static bool ShouldGenerateCopyInstructionForMatchOfSize(size_t size) {
+    return size >= kMinimumMatchSize;
+  }
+
+  size_t EncodeCopyForBestMatch(uint32_t hash_value,
+                                const char* target_candidate_start,
+                                const char* unencoded_target_start,
+                                size_t unencoded_target_size,
+                                const BlockHash* target_hash,
+                                VCDiffCodeTableWriter* coder) const;
+
+  void AddUnmatchedRemainder(const char* unencoded_target_start,
+                             size_t unencoded_target_size,
+                             VCDiffCodeTableWriter* coder) const;
+
+  void FinishEncoding(size_t target_size,
+                      OutputStringInterface* diff,
+                      VCDiffCodeTableWriter* coder) const;
+
+  const string dictionary_;  // A copy of the dictionary contents
+
+  // A hash that contains one element for every kBlockSize bytes of dictionary_.
+  // This can be reused to encode many different target strings using the
+  // same dictionary, without the need to compute the hash values each time.
+  const BlockHash* hashed_dictionary_;
+
+  // Making these private avoids implicit copy constructor & assignment operator
+  VCDiffEngine(const VCDiffEngine&);
+  void operator=(const VCDiffEngine&);
+};
+
+}  // namespace open_vcdiff
+
+#endif  // OPEN_VCDIFF_VCDIFFENGINE_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdiffengine_test.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdiffengine_test.cc
new file mode 100644
index 0000000..a115adc
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcdiffengine_test.cc
@@ -0,0 +1,1002 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <config.h>
+#include "vcdiffengine.h"
+#include <algorithm>
+#include <string>
+#include <vector>
+#include "addrcache.h"
+#include "blockhash.h"
+#include "encodetable.h"
+#include "google/output_string.h"
+#include "rolling_hash.h"
+#include "testing.h"
+#include "varint_bigendian.h"
+#include "vcdiff_defs.h"
+
+namespace open_vcdiff {
+
+namespace {
+
+using std::string;
+
+class VCDiffEngineTestBase : public testing::Test {
+ protected:
+  // Some common definitions and helper functions used in the various tests
+  // for VCDiffEngine.
+  static const int kBlockSize = BlockHash::kBlockSize;
+
+  VCDiffEngineTestBase() : interleaved_(false),
+                           diff_output_string_(&diff_),
+                           verify_position_(0),
+                           saved_total_size_position_(0),
+                           saved_delta_encoding_position_(0),
+                           saved_section_sizes_position_(0),
+                           data_bytes_(0),
+                           instruction_bytes_(0),
+                           address_bytes_(0) { }
+
+  virtual ~VCDiffEngineTestBase() { }
+
+  virtual void TearDown() {
+    VerifyMatchCounts();
+  }
+
+  // Copy string_without_spaces into newly allocated result buffer,
+  // but pad its contents with space characters so that every character
+  // in string_without_spaces corresponds to (block_size - 1)
+  // spaces in the result, followed by that character.
+  // For example:
+  // If string_without_spaces begins "The only thing"... and block_size is 4,
+  // then 3 space characters will be inserted
+  // between each letter in the result, as follows:
+  // "   T   h   e       o   n   l   y       t   h   i   n   g"...
+  // This makes testing simpler, because finding a block_size-byte match
+  // between the dictionary and target only depends on the
+  // trailing letter in each block.
+  // If no_initial_padding is true, then the first letter will not have
+  // spaces added in front of it.
+  static void MakeEachLetterABlock(const char* string_without_spaces,
+                                   const char** result,
+                                   int block_size,
+                                   bool no_initial_padding) {
+    const size_t length_without_spaces = strlen(string_without_spaces);
+    char* padded_text = new char[(block_size * length_without_spaces) + 1];
+    memset(padded_text, ' ', block_size * length_without_spaces);
+    char* padded_text_ptr = padded_text;
+    if (!no_initial_padding) {
+      padded_text_ptr += block_size - 1;
+    }
+    for (size_t i = 0; i < length_without_spaces; ++i) {
+      *padded_text_ptr = string_without_spaces[i];
+      padded_text_ptr += block_size;
+    }
+    *(padded_text_ptr - block_size + 1)  = '\0';
+    *result = padded_text;
+  }
+
+  // These functions iterate through the decoded output and expect
+  // simple elements: bytes or variable-length integers.
+  void ExpectByte(char byte) {
+    EXPECT_GT(diff_.size(), verify_position_);
+    EXPECT_EQ(byte, diff_[verify_position_]);
+    ++verify_position_;
+  }
+
+  size_t ExpectVarint(int32_t expected_value) {
+    EXPECT_GT(diff_.size(), verify_position_);
+    const char* const original_position = &diff_[verify_position_];
+    const char* new_position = original_position;
+    const size_t expected_length = VarintBE<int32_t>::Length(expected_value);
+    int32_t parsed_value = VarintBE<int32_t>::Parse(diff_.data() + diff_.size(),
+                                                    &new_position);
+    EXPECT_LE(0, parsed_value);
+    size_t parsed_length = new_position - original_position;
+    EXPECT_EQ(expected_value, parsed_value);
+    EXPECT_EQ(expected_length, parsed_length);
+    verify_position_ += parsed_length;
+    return parsed_length;
+  }
+
+  size_t ExpectSize(size_t size) {
+    return ExpectVarint(static_cast<int32_t>(size));
+  }
+
+  size_t ExpectStringLength(const char* s) {
+    return ExpectSize(strlen(s));
+  }
+
+  void SkipVarint() {
+    EXPECT_GT(diff_.size(), verify_position_);
+    const char* const original_position = &diff_[verify_position_];
+    const char* new_position = original_position;
+    VarintBE<int32_t>::Parse(diff_.data() + diff_.size(), &new_position);
+    size_t parsed_length = new_position - original_position;
+    verify_position_ += parsed_length;
+  }
+
+  void ExpectDataByte(char byte) {
+    ExpectByte(byte);
+    if (interleaved_) {
+      ++instruction_bytes_;
+    } else {
+      ++data_bytes_;
+    }
+  }
+
+  void ExpectDataString(const char *expected_string) {
+    const char* ptr = expected_string;
+    while (*ptr) {
+      ExpectDataByte(*ptr);
+      ++ptr;
+    }
+  }
+
+  void ExpectDataStringWithBlockSpacing(const char *expected_string,
+                                        bool trailing_spaces) {
+    const char* ptr = expected_string;
+    while (*ptr) {
+      for (int i = 0; i < (kBlockSize - 1); ++i) {
+        ExpectDataByte(' ');
+      }
+      ExpectDataByte(*ptr);
+      ++ptr;
+    }
+    if (trailing_spaces) {
+      for (int i = 0; i < (kBlockSize - 1); ++i) {
+        ExpectDataByte(' ');
+      }
+    }
+  }
+
+  void ExpectInstructionByte(char byte) {
+    ExpectByte(byte);
+    ++instruction_bytes_;
+  }
+
+  void ExpectInstructionVarint(int32_t value) {
+    instruction_bytes_ += ExpectVarint(value);
+  }
+
+  void ExpectAddressByte(char byte) {
+    ExpectByte(byte);
+    if (interleaved_) {
+      ++instruction_bytes_;
+    } else {
+      ++address_bytes_;
+    }
+  }
+
+  void ExpectAddressVarint(int32_t value) {
+    if (interleaved_) {
+      instruction_bytes_ += ExpectVarint(value);
+    } else {
+      address_bytes_ += ExpectVarint(value);
+    }
+  }
+
+  // The following functions leverage the fact that the encoder uses
+  // the default code table and cache sizes.  They are able to search for
+  // instructions of a particular size.  The logic for mapping from
+  // instruction type, mode, and size to opcode value is very different here
+  // from the logic used in encodetable.{h,cc}, so hopefully
+  // this version will help validate that the other is correct.
+  // This version uses conditional statements, while encodetable.h
+  // looks up values in a mapping table.
+  void ExpectAddress(int32_t address, int copy_mode) {
+    if ((copy_mode >= default_cache_.FirstSameMode()) &&
+        (copy_mode <= default_cache_.LastMode())) {
+      ExpectAddressByte(address);
+    } else {
+      ExpectAddressVarint(address);
+    }
+  }
+
+  void ExpectAddInstruction(int size) {
+    if (size <= 18) {
+      ExpectInstructionByte(0x01 + size);
+    } else {
+      ExpectInstructionByte(0x01);
+      ExpectInstructionVarint(size);
+    }
+  }
+
+  void ExpectCopyInstruction(int size, int mode) {
+    if ((size >= 4) && (size <= 16)) {
+      ExpectInstructionByte(0x10 + (0x10 * mode) + size);
+    } else {
+      ExpectInstructionByte(0x13 + (0x10 * mode));
+      ExpectInstructionVarint(size);
+    }
+    ExpectMatch(size);
+  }
+
+  bool ExpectAddCopyInstruction(int add_size, int copy_size, int copy_mode) {
+    if ((copy_mode < default_cache_.FirstSameMode()) &&
+        (add_size <= 4) &&
+        (copy_size >= 4) &&
+        (copy_size <= 6)) {
+      ExpectInstructionByte(0x9C +
+                            (0x0C * copy_mode) +
+                            (0x03 * add_size) +
+                            copy_size);
+      ExpectMatch(copy_size);
+      return true;
+    } else if ((copy_mode >= default_cache_.FirstSameMode()) &&
+               (add_size <= 4) &&
+               (copy_size == 4)) {
+      ExpectInstructionByte(0xD2 + (0x04 * copy_mode) + add_size);
+      ExpectMatch(copy_size);
+      return true;
+    } else {
+      ExpectAddInstruction(add_size);
+      return false;
+    }
+  }
+
+  void ExpectAddInstructionForStringLength(const char* s) {
+    ExpectAddInstruction(static_cast<int>(strlen(s)));
+  }
+
+  // Call this function before beginning to iterate through the diff string
+  // using the Expect... functions.
+  // text must be NULL-terminated.
+  void VerifyHeaderForDictionaryAndTargetText(const char* dictionary,
+                                              const char* target_text) {
+    ExpectByte(0x01);  // Win_Indicator: VCD_SOURCE (dictionary)
+    ExpectStringLength(dictionary);
+    ExpectByte(0x00);  // Source segment position: start of dictionary
+    saved_total_size_position_ = verify_position_;
+    SkipVarint();  // Length of the delta encoding
+    saved_delta_encoding_position_ = verify_position_;
+    ExpectStringLength(target_text);
+    ExpectByte(0x00);  // Delta_indicator (no compression)
+    saved_section_sizes_position_ = verify_position_;
+    SkipVarint();  // length of data for ADDs and RUNs
+    SkipVarint();  // length of instructions section
+    SkipVarint();  // length of addresses for COPYs
+  }
+
+  // Call this function before beginning to iterating through the entire
+  // diff string using the Expect... functions.  It makes sure that the
+  // size totals in the window header match the number of bytes that
+  // were parsed.
+  void VerifySizes() {
+    EXPECT_EQ(verify_position_, diff_.size());
+    const size_t delta_encoding_size = verify_position_ -
+                                       saved_delta_encoding_position_;
+    verify_position_ = saved_total_size_position_;
+    ExpectSize(delta_encoding_size);
+    verify_position_ = saved_section_sizes_position_;
+    ExpectSize(data_bytes_);
+    ExpectSize(instruction_bytes_);
+    ExpectSize(address_bytes_);
+  }
+
+  void ExpectMatch(size_t match_size) {
+    if (match_size >= expected_match_counts_.size()) {
+      // Be generous to avoid resizing again
+      expected_match_counts_.resize(match_size * 2, 0);
+    }
+    ++expected_match_counts_[match_size];
+  }
+
+  void VerifyMatchCounts() {
+    EXPECT_TRUE(std::equal(expected_match_counts_.begin(),
+                           expected_match_counts_.end(),
+                           actual_match_counts_.begin()));
+  }
+
+  bool interleaved_;
+  string diff_;
+  OutputString<string> diff_output_string_;
+  size_t verify_position_;
+  size_t saved_total_size_position_;
+  size_t saved_delta_encoding_position_;
+  size_t saved_section_sizes_position_;
+  size_t data_bytes_;
+  size_t instruction_bytes_;
+  size_t address_bytes_;
+  VCDiffAddressCache default_cache_;  // Used for finding mode values
+  std::vector<int> expected_match_counts_;
+  std::vector<int> actual_match_counts_;
+};
+
+class VCDiffEngineTest : public VCDiffEngineTestBase {
+ protected:
+  VCDiffEngineTest() :
+      engine_(dictionary_, strlen(dictionary_)) {
+    EXPECT_TRUE(const_cast<VCDiffEngine*>(&engine_)->Init());
+  }
+
+  virtual ~VCDiffEngineTest() { }
+
+
+  static void SetUpTestCase() {
+    MakeEachLetterABlock(dictionary_without_spaces_, &dictionary_,
+                         kBlockSize, false);
+    MakeEachLetterABlock(target_without_spaces_, &target_, kBlockSize, false);
+  }
+
+  static void TearDownTestCase() {
+    delete[] dictionary_;
+    delete[] target_;
+  }
+
+  void EncodeNothing(bool interleaved, bool target_matching) {
+    interleaved_ = interleaved;
+    VCDiffCodeTableWriter coder(interleaved);
+    engine_.Encode("", 0, target_matching, &diff_output_string_, &coder);
+    EXPECT_TRUE(diff_.empty());
+    actual_match_counts_ = coder.match_counts();
+  }
+
+  // text must be NULL-terminated
+  void EncodeText(const char* text, bool interleaved, bool target_matching) {
+    interleaved_ = interleaved;
+    VCDiffCodeTableWriter coder(interleaved);
+    engine_.Encode(text,
+                   strlen(text),
+                   target_matching,
+                   &diff_output_string_,
+                   &coder);
+    actual_match_counts_ = coder.match_counts();
+  }
+
+  void Encode(bool interleaved, bool target_matching) {
+    EncodeText(target_, interleaved, target_matching);
+    VerifyHeader();
+  }
+
+  void VerifyHeader() {
+    VerifyHeaderForDictionaryAndTargetText(dictionary_, target_);
+  }
+
+  static const char dictionary_without_spaces_[];
+  static const char target_without_spaces_[];
+
+  static const char* dictionary_;
+  static const char* target_;
+
+  const VCDiffEngine engine_;
+};
+
+#ifdef GTEST_HAS_DEATH_TEST
+typedef VCDiffEngineTest VCDiffEngineDeathTest;
+#endif  // GTEST_HAS_DEATH_TEST
+
+const char VCDiffEngineTest::dictionary_without_spaces_[] =
+    "The only thing we have to fear is fear itself";
+
+const char VCDiffEngineTest::target_without_spaces_[] =
+    "What we hear is fearsome";
+
+const char* VCDiffEngineTest::dictionary_ = NULL;
+const char* VCDiffEngineTest::target_ = NULL;
+
+#ifdef GTEST_HAS_DEATH_TEST
+TEST_F(VCDiffEngineDeathTest, InitCalledTwice) {
+  EXPECT_DEBUG_DEATH(EXPECT_FALSE(const_cast<VCDiffEngine*>(&engine_)->Init()),
+                     "twice");
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+TEST_F(VCDiffEngineTest, EngineEncodeNothing) {
+  EncodeNothing(/* interleaved = */ false, /* target matching = */ false);
+}
+
+TEST_F(VCDiffEngineTest, EngineEncodeNothingInterleaved) {
+  EncodeNothing(/* interleaved = */ true, /* target matching = */ false);
+}
+
+TEST_F(VCDiffEngineTest, EngineEncodeNothingTarget) {
+  EncodeNothing(/* interleaved = */ false, /* target matching = */ true);
+}
+
+TEST_F(VCDiffEngineTest, EngineEncodeNothingTargetInterleaved) {
+  EncodeNothing(/* interleaved = */ true, /* target matching = */ true);
+}
+
+TEST_F(VCDiffEngineTest, EngineEncodeSmallerThanOneBlock) {
+  const char* small_text = "  ";
+  EncodeText(small_text,
+             /* interleaved = */ false,
+             /* target matching = */ false);
+  VerifyHeaderForDictionaryAndTargetText(dictionary_, small_text);
+  // Data for ADDs
+  ExpectDataString(small_text);
+  // Instructions and sizes
+  ExpectAddInstructionForStringLength(small_text);
+}
+
+TEST_F(VCDiffEngineTest, EngineEncodeSmallerThanOneBlockInterleaved) {
+  const char* small_text = "  ";
+  EncodeText(small_text,
+             /* interleaved = */ true,
+             /* target matching = */ false);
+  VerifyHeaderForDictionaryAndTargetText(dictionary_, small_text);
+  // Interleaved section
+  ExpectAddInstructionForStringLength(small_text);
+  ExpectDataString(small_text);
+}
+
+TEST_F(VCDiffEngineTest, EngineEncodeSampleText) {
+  Encode(/* interleaved = */ false, /* target matching = */ false);
+  // Data for ADDs
+  ExpectDataStringWithBlockSpacing("W", false);
+  ExpectDataByte('t');
+  ExpectDataByte('s');
+  if (kBlockSize < 4) {
+    ExpectDataStringWithBlockSpacing("ome", false);
+  } else {
+    ExpectDataByte('m');
+  }
+  // Instructions and sizes
+  if (!ExpectAddCopyInstruction(kBlockSize, (3 * kBlockSize) - 1,
+                                VCD_SELF_MODE)) {
+    ExpectCopyInstruction((3 * kBlockSize) - 1, VCD_SELF_MODE);
+  }
+  ExpectAddInstruction(1);
+  ExpectCopyInstruction((6 * kBlockSize) - 1, VCD_SELF_MODE);
+  ExpectCopyInstruction(11 * kBlockSize,
+                        default_cache_.FirstNearMode());
+  if (kBlockSize < 4) {
+    // Copy instructions of size kBlockSize and (2 * kBlockSize) - 1
+    // are too small to be selected
+    ExpectAddInstruction((3 * kBlockSize) + 1);
+  } else {
+    if (!ExpectAddCopyInstruction(1, (2 * kBlockSize) - 1, VCD_SELF_MODE)) {
+      ExpectCopyInstruction((2 * kBlockSize) - 1, VCD_SELF_MODE);
+    }
+    if (!ExpectAddCopyInstruction(1, kBlockSize, VCD_SELF_MODE)) {
+      ExpectCopyInstruction(kBlockSize, VCD_SELF_MODE);
+    }
+  }
+  // Addresses for COPY
+  ExpectAddressVarint(18 * kBlockSize);  // "ha"
+  ExpectAddressVarint(14 * kBlockSize);  // " we h"
+  ExpectAddressVarint((9 * kBlockSize) + (kBlockSize - 1));  // "ear is fear"
+  if (kBlockSize >= 4) {
+    ExpectAddressVarint(4 * kBlockSize);  // "o" from "The only"
+    ExpectAddressVarint(2 * kBlockSize);  // "e" from "The only"
+  }
+  VerifySizes();
+}
+
+TEST_F(VCDiffEngineTest, EngineEncodeSampleTextInterleaved) {
+  Encode(/* interleaved = */ true, /* target matching = */ false);
+  // Interleaved section
+  if (!ExpectAddCopyInstruction(kBlockSize, (3 * kBlockSize) - 1,
+                                VCD_SELF_MODE)) {
+    ExpectDataStringWithBlockSpacing("W", false);
+    ExpectCopyInstruction((3 * kBlockSize) - 1, VCD_SELF_MODE);
+  } else {
+    ExpectDataStringWithBlockSpacing("W", false);
+  }
+  ExpectAddressVarint(18 * kBlockSize);  // "ha"
+  ExpectAddInstruction(1);
+  ExpectDataByte('t');
+  ExpectCopyInstruction((6 * kBlockSize) - 1, VCD_SELF_MODE);
+  ExpectAddressVarint(14 * kBlockSize);  // " we h"
+  ExpectCopyInstruction(11 * kBlockSize,
+                        default_cache_.FirstNearMode());
+  ExpectAddressVarint((9 * kBlockSize) + (kBlockSize - 1));  // "ear is fear"
+  if (kBlockSize < 4) {
+    // Copy instructions of size kBlockSize and (2 * kBlockSize) - 1
+    // are too small to be selected
+    ExpectAddInstruction((3 * kBlockSize) + 1);
+    ExpectDataByte('s');
+    ExpectDataStringWithBlockSpacing("ome", false);
+  } else {
+    if (!ExpectAddCopyInstruction(1, (2 * kBlockSize) - 1, VCD_SELF_MODE)) {
+      ExpectDataByte('s');
+      ExpectCopyInstruction((2 * kBlockSize) - 1, VCD_SELF_MODE);
+    } else {
+      ExpectDataByte('s');
+    }
+    ExpectAddressVarint(4 * kBlockSize);  // "o" from "The only"
+    if (!ExpectAddCopyInstruction(1, kBlockSize, VCD_SELF_MODE)) {
+      ExpectDataByte('m');
+      ExpectCopyInstruction(kBlockSize, VCD_SELF_MODE);
+    } else {
+      ExpectDataByte('m');
+    }
+    ExpectAddressVarint(2 * kBlockSize);  // "e" from "The only"
+  }
+  VerifySizes();
+}
+
+TEST_F(VCDiffEngineTest, EngineEncodeSampleTextWithTargetMatching) {
+  Encode(/* interleaved = */ false, /* target matching = */ true);
+  // Data for ADDs
+  ExpectDataStringWithBlockSpacing("W", false);
+  ExpectDataByte('t');
+  ExpectDataByte('s');
+  if (kBlockSize < 4) {
+    ExpectDataStringWithBlockSpacing("ome", false);
+  } else {
+    ExpectDataByte('m');
+  }
+  // Instructions and sizes
+  if (!ExpectAddCopyInstruction(kBlockSize, (3 * kBlockSize) - 1,
+                                VCD_SELF_MODE)) {
+    ExpectCopyInstruction((3 * kBlockSize) - 1, VCD_SELF_MODE);
+  }
+  ExpectAddInstruction(1);
+  ExpectCopyInstruction((6 * kBlockSize) - 1, VCD_SELF_MODE);
+  ExpectCopyInstruction(11 * kBlockSize,
+                        default_cache_.FirstNearMode());
+  if (kBlockSize < 4) {
+    // Copy instructions of size kBlockSize and (2 * kBlockSize) - 1
+    // are too small to be selected
+    ExpectAddInstruction((3 * kBlockSize) + 1);
+  } else {
+    if (!ExpectAddCopyInstruction(1, (2 * kBlockSize) - 1, VCD_SELF_MODE)) {
+      ExpectCopyInstruction((2 * kBlockSize) - 1, VCD_SELF_MODE);
+    }
+    if (!ExpectAddCopyInstruction(1, kBlockSize, VCD_SELF_MODE)) {
+      ExpectCopyInstruction(kBlockSize, VCD_SELF_MODE);
+    }
+  }
+  // Addresses for COPY
+  ExpectAddressVarint(18 * kBlockSize);  // "ha"
+  ExpectAddressVarint(14 * kBlockSize);  // " we h"
+  ExpectAddressVarint((9 * kBlockSize) + (kBlockSize - 1));  // "ear is fear"
+  if (kBlockSize >= 4) {
+    ExpectAddressVarint(4 * kBlockSize);  // "o" from "The only"
+    ExpectAddressVarint(2 * kBlockSize);  // "e" from "The only"
+  }
+  VerifySizes();
+}
+
+TEST_F(VCDiffEngineTest, EngineEncodeSampleTextInterleavedWithTargetMatching) {
+  Encode(/* interleaved = */ true, /* target matching = */ false);
+  // Interleaved section
+  if (!ExpectAddCopyInstruction(kBlockSize, (3 * kBlockSize) - 1,
+                                VCD_SELF_MODE)) {
+    ExpectDataStringWithBlockSpacing("W", false);
+    ExpectCopyInstruction((3 * kBlockSize) - 1, VCD_SELF_MODE);
+  } else {
+    ExpectDataStringWithBlockSpacing("W", false);
+  }
+  ExpectAddressVarint(18 * kBlockSize);  // "ha"
+  ExpectAddInstruction(1);
+  ExpectDataByte('t');
+  ExpectCopyInstruction((6 * kBlockSize) - 1, VCD_SELF_MODE);
+  ExpectAddressVarint(14 * kBlockSize);  // " we h"
+  ExpectCopyInstruction(11 * kBlockSize,
+                        default_cache_.FirstNearMode());
+  ExpectAddressVarint((9 * kBlockSize) + (kBlockSize - 1));  // "ear is fear"
+  if (kBlockSize < 4) {
+    // Copy instructions of size kBlockSize and (2 * kBlockSize) - 1
+    // are too small to be selected
+    ExpectAddInstruction((3 * kBlockSize) + 1);
+    ExpectDataByte('s');
+    ExpectDataStringWithBlockSpacing("ome", false);
+  } else {
+    if (!ExpectAddCopyInstruction(1, (2 * kBlockSize) - 1, VCD_SELF_MODE)) {
+      ExpectDataByte('s');
+      ExpectCopyInstruction((2 * kBlockSize) - 1, VCD_SELF_MODE);
+    } else {
+      ExpectDataByte('s');
+    }
+    ExpectAddressVarint(4 * kBlockSize);  // "o" from "The only"
+    if (!ExpectAddCopyInstruction(1, kBlockSize, VCD_SELF_MODE)) {
+      ExpectDataByte('m');
+      ExpectCopyInstruction(kBlockSize, VCD_SELF_MODE);
+    } else {
+      ExpectDataByte('m');
+    }
+    ExpectAddressVarint(2 * kBlockSize);  // "e" from "The only"
+  }
+  VerifySizes();
+}
+
+// This test case takes a dictionary containing several instances of the string
+// "weasel", and a target string which is identical to the dictionary
+// except that all instances of "weasel" have been replaced with the string
+// "moon-pie".  It tests that COPY instructions are generated for all
+// boilerplate text (that is, the text between the "moon-pie" instances in
+// the target) and, if target matching is enabled, that each instance of
+// "moon-pie" (except the first one) is encoded using a COPY instruction
+// rather than an ADD.
+class WeaselsToMoonpiesTest : public VCDiffEngineTestBase {
+ protected:
+  // kCompressibleTestBlockSize:
+  // The size of the block to create for each letter in the
+  // dictionary and search string for the "compressible text" test.
+  // See MakeEachLetterABlock, below.
+  // If we use kCompressibleTestBlockSize = kBlockSize, then the
+  // encoder will find one match per unique letter in the HTML text.
+  // There are too many examples of "<" in the text for the encoder
+  // to iterate through them all, and some matches are not found.
+  // If we use kCompressibleTextBlockSize = 1, then the boilerplate
+  // text between "weasel" strings in the dictionary and "moon-pie"
+  // strings in the target may not be long enough to be found by
+  // the encoder's block-hash algorithm.  A good value, that will give
+  // reproducible results across all block sizes, will be somewhere
+  // in between these extremes.
+  static const int kCompressibleTestBlockSize =
+      (kBlockSize < 4) ? 1 : kBlockSize / 4;
+  static const int kTrailingSpaces = kCompressibleTestBlockSize - 1;
+
+  WeaselsToMoonpiesTest() :
+      engine_(dictionary_, strlen(dictionary_)),
+      match_index_(0),
+      search_dictionary_(dictionary_, strlen(dictionary_)),
+      copied_moonpie_address_(0) {
+    EXPECT_TRUE(const_cast<VCDiffEngine*>(&engine_)->Init());
+    weasel_positions_[0] = 0;
+    after_weasel_[0] = 0;
+    moonpie_positions_[0] = 0;
+    after_moonpie_[0] = 0;
+  }
+
+  virtual ~WeaselsToMoonpiesTest() { }
+
+  static void SetUpTestCase() {
+    MakeEachLetterABlock(dictionary_without_spaces_,
+                         &dictionary_,
+                         kCompressibleTestBlockSize,
+                         false);
+    MakeEachLetterABlock(target_without_spaces_,
+                         &target_,
+                         kCompressibleTestBlockSize,
+                         false);
+    MakeEachLetterABlock(weasel_text_without_spaces_,
+                         &weasel_text_,
+                         kCompressibleTestBlockSize,
+                         true);
+    MakeEachLetterABlock(moonpie_text_without_spaces_,
+                         &moonpie_text_,
+                         kCompressibleTestBlockSize,
+                         true);
+  }
+
+  static void TearDownTestCase() {
+    delete[] dictionary_;
+    delete[] target_;
+    delete[] weasel_text_;
+    delete[] moonpie_text_;
+  }
+
+  // text must be NULL-terminated
+  void EncodeText(const char* text, bool interleaved, bool target_matching) {
+    interleaved_ = interleaved;
+    VCDiffCodeTableWriter coder(interleaved);
+    engine_.Encode(text,
+                   strlen(text),
+                   target_matching,
+                   &diff_output_string_,
+                   &coder);
+    actual_match_counts_ = coder.match_counts();
+  }
+
+  void Encode(bool interleaved, bool target_matching) {
+    EncodeText(target_, interleaved, target_matching);
+    VerifyHeader();
+  }
+
+  void VerifyHeader() {
+    VerifyHeaderForDictionaryAndTargetText(dictionary_, target_);
+  }
+
+  void ExpectCopyForSize(size_t size, int mode) {
+    ExpectCopyInstruction(static_cast<int>(size), mode);
+  }
+
+  void ExpectAddForSize(size_t size) {
+    ExpectAddInstruction(static_cast<int>(size));
+  }
+
+  void ExpectAddressVarintForSize(size_t value) {
+    ExpectAddressVarint(static_cast<int32_t>(value));
+  }
+
+  void FindNextMoonpie(bool include_trailing_spaces) {
+    ++match_index_;
+    SetCurrentWeaselPosition(search_dictionary_.find(weasel_text_,
+                                                     AfterLastWeasel()));
+    if (CurrentWeaselPosition() == string::npos) {
+      SetCurrentMoonpiePosition(string::npos);
+    } else {
+      SetCurrentAfterWeaselPosition(CurrentWeaselPosition()
+                                        + strlen(weasel_text_)
+                                        + (include_trailing_spaces ?
+                                            kTrailingSpaces : 0));
+      SetCurrentMoonpiePosition(AfterLastMoonpie()
+                                    + CurrentBoilerplateLength());
+      SetCurrentAfterMoonpiePosition(CurrentMoonpiePosition()
+                                        + strlen(moonpie_text_)
+                                        + (include_trailing_spaces ?
+                                            kTrailingSpaces : 0));
+    }
+  }
+  bool NoMoreMoonpies() const {
+    return CurrentMoonpiePosition() == string::npos;
+  }
+  size_t CurrentWeaselPosition() const {
+    return weasel_positions_[match_index_];
+  }
+  size_t LastWeaselPosition() const {
+    return weasel_positions_[match_index_ - 1];
+  }
+  size_t CurrentMoonpiePosition() const {
+    return moonpie_positions_[match_index_];
+  }
+  size_t LastMoonpiePosition() const {
+    return moonpie_positions_[match_index_ - 1];
+  }
+  size_t AfterLastWeasel() const {
+    CHECK_GE(match_index_, 1);
+    return after_weasel_[match_index_ - 1];
+  }
+  size_t AfterPreviousWeasel() const {
+    CHECK_GE(match_index_, 2);
+    return after_weasel_[match_index_ - 2];
+  }
+  size_t AfterLastMoonpie() const {
+    CHECK_GE(match_index_, 1);
+    return after_moonpie_[match_index_ - 1];
+  }
+  size_t AfterPreviousMoonpie() const {
+    CHECK_GE(match_index_, 2);
+    return after_moonpie_[match_index_ - 2];
+  }
+
+  void SetCurrentWeaselPosition(size_t value) {
+    weasel_positions_[match_index_] = value;
+  }
+  void SetCurrentAfterWeaselPosition(size_t value) {
+    after_weasel_[match_index_] = value;
+  }
+  void SetCurrentMoonpiePosition(size_t value) {
+    moonpie_positions_[match_index_] = value;
+  }
+  void SetCurrentAfterMoonpiePosition(size_t value) {
+    after_moonpie_[match_index_] = value;
+  }
+
+  // Find the length of the text in between the "weasel" strings in the
+  // compressible dictionary, which is the same as the text between
+  // the "moon-pie" strings in the compressible target.
+  size_t CurrentBoilerplateLength() const {
+    CHECK_GE(match_index_, 1);
+    return CurrentWeaselPosition() - AfterLastWeasel();
+  }
+  size_t DistanceFromLastWeasel() const {
+    CHECK_GE(match_index_, 1);
+    return CurrentWeaselPosition() - LastWeaselPosition();
+  }
+  size_t DistanceFromLastMoonpie() const {
+    CHECK_GE(match_index_, 1);
+    return CurrentMoonpiePosition() - LastMoonpiePosition();
+  }
+  size_t DistanceBetweenLastTwoWeasels() const {
+    CHECK_GE(match_index_, 2);
+    return AfterLastWeasel() - AfterPreviousWeasel();
+  }
+  size_t DistanceBetweenLastTwoMoonpies() const {
+    CHECK_GE(match_index_, 2);
+    return AfterLastMoonpie() - AfterPreviousMoonpie();
+  }
+
+  int32_t FindBoilerplateAddressForCopyMode(int copy_mode) const;
+  int UpdateCopyModeForMoonpie(int copy_mode) const;
+  int32_t FindMoonpieAddressForCopyMode(int copy_mode) const;
+
+  void CopyBoilerplateAndAddMoonpie(int copy_mode);
+  void CopyBoilerplateAndCopyMoonpie(int copy_mode, int moonpie_copy_mode);
+
+  static const char dictionary_without_spaces_[];
+  static const char target_without_spaces_[];
+  static const char weasel_text_without_spaces_[];
+  static const char moonpie_text_without_spaces_[];
+
+  static const char* dictionary_;
+  static const char* target_;
+  static const char* weasel_text_;
+  static const char* moonpie_text_;
+
+  const VCDiffEngine engine_;
+  size_t weasel_positions_[128];
+  size_t after_weasel_[128];
+  size_t moonpie_positions_[128];
+  size_t after_moonpie_[128];
+  int match_index_;
+  string search_dictionary_;
+  size_t copied_moonpie_address_;
+};
+
+// Care is taken in the formulation of the dictionary
+// to ensure that the surrounding letters do not match; for example,
+// there are not two instances of the string "weasels".  Otherwise,
+// the matching behavior would not be as predictable.
+const char WeaselsToMoonpiesTest::dictionary_without_spaces_[] =
+  "<html>\n"
+  "<head>\n"
+  "<meta content=\"text/html; charset=ISO-8859-1\"\n"
+  "http-equiv=\"content-type\">\n"
+  "<title>All about weasels</title>\n"
+  "</head>\n"
+  "<!-- You will notice that the word \"weasel\" may be replaced"
+  " with something else -->\n"
+  "<body>\n"
+  "<h1>All about the weasel: highly compressible HTML text</h1>"
+  "<ul>\n"
+  "<li>Don\'t look a gift weasel in its mouth.</li>\n"
+  "<li>This item makes sure the next occurrence is found.</li>\n"
+  "<li>Don\'t count your weasel, before it\'s hatched.</li>\n"
+  "</ul>\n"
+  "<br>\n"
+  "</body>\n"
+  "</html>\n";
+
+const char WeaselsToMoonpiesTest::target_without_spaces_[] =
+  "<html>\n"
+  "<head>\n"
+  "<meta content=\"text/html; charset=ISO-8859-1\"\n"
+  "http-equiv=\"content-type\">\n"
+  "<title>All about moon-pies</title>\n"
+  "</head>\n"
+  "<!-- You will notice that the word \"moon-pie\" may be replaced"
+  " with something else -->\n"
+  "<body>\n"
+  "<h1>All about the moon-pie: highly compressible HTML text</h1>"
+  "<ul>\n"
+  "<li>Don\'t look a gift moon-pie in its mouth.</li>\n"
+  "<li>This item makes sure the next occurrence is found.</li>\n"
+  "<li>Don\'t count your moon-pie, before it\'s hatched.</li>\n"
+  "</ul>\n"
+  "<br>\n"
+  "</body>\n"
+  "</html>\n";
+
+const char WeaselsToMoonpiesTest::weasel_text_without_spaces_[] = "weasel";
+const char WeaselsToMoonpiesTest::moonpie_text_without_spaces_[] = "moon-pie";
+
+const char* WeaselsToMoonpiesTest::dictionary_ = NULL;
+const char* WeaselsToMoonpiesTest::target_ = NULL;
+const char* WeaselsToMoonpiesTest::weasel_text_ = NULL;
+const char* WeaselsToMoonpiesTest::moonpie_text_ = NULL;
+
+int32_t WeaselsToMoonpiesTest::FindBoilerplateAddressForCopyMode(
+    int copy_mode) const {
+  size_t copy_address = 0;
+  if (copy_mode == VCD_SELF_MODE) {
+    copy_address = AfterLastWeasel();
+  } else if ((copy_mode >= default_cache_.FirstNearMode()) &&
+             (copy_mode < default_cache_.FirstSameMode())) {
+    copy_address = DistanceBetweenLastTwoWeasels();
+  } else if ((copy_mode >= default_cache_.FirstSameMode()) &&
+             (copy_mode <= default_cache_.LastMode())) {
+    copy_address = AfterLastWeasel() % 256;
+  } else {
+    LOG(FATAL) << "Unexpected copy mode " << copy_mode;
+  }
+  return static_cast<int32_t>(copy_address);
+}
+
+int WeaselsToMoonpiesTest::UpdateCopyModeForMoonpie(int copy_mode) const {
+  if (copy_mode == default_cache_.FirstSameMode()) {
+    return default_cache_.FirstSameMode()
+        + static_cast<int>((copied_moonpie_address_ / 256) % 3);
+  } else {
+    return copy_mode;
+  }
+}
+
+int32_t WeaselsToMoonpiesTest::FindMoonpieAddressForCopyMode(
+    int copy_mode) const {
+  size_t copy_address = 0;
+  if (copy_mode == VCD_HERE_MODE) {
+    copy_address = DistanceFromLastMoonpie();
+  } else if ((copy_mode >= default_cache_.FirstNearMode()) &&
+             (copy_mode < default_cache_.FirstSameMode())) {
+    copy_address = DistanceBetweenLastTwoMoonpies() - kTrailingSpaces;
+  } else if ((copy_mode >= default_cache_.FirstSameMode()) &&
+             (copy_mode <= default_cache_.LastMode())) {
+    copy_address = copied_moonpie_address_ % 256;
+  } else {
+    LOG(FATAL) << "Unexpected copy mode " << copy_mode;
+  }
+  return static_cast<int32_t>(copy_address);
+}
+
+// Expect one dictionary instance of "weasel" to be replaced with "moon-pie"
+// in the encoding.
+void WeaselsToMoonpiesTest::CopyBoilerplateAndAddMoonpie(int copy_mode) {
+  EXPECT_FALSE(NoMoreMoonpies());
+  ExpectCopyForSize(CurrentBoilerplateLength(), copy_mode);
+  ExpectAddress(FindBoilerplateAddressForCopyMode(copy_mode), copy_mode);
+  ExpectAddInstructionForStringLength(moonpie_text_);
+  ExpectDataString(moonpie_text_);
+}
+
+// Expect one dictionary instance of "weasel" to be replaced with "moon-pie"
+// in the encoding.  The "moon-pie" text will be copied from the previously
+// encoded target.
+void WeaselsToMoonpiesTest::CopyBoilerplateAndCopyMoonpie(
+    int copy_mode,
+    int moonpie_copy_mode) {
+  EXPECT_FALSE(NoMoreMoonpies());
+  ExpectCopyForSize(CurrentBoilerplateLength(), copy_mode);
+  ExpectAddress(FindBoilerplateAddressForCopyMode(copy_mode), copy_mode);
+  moonpie_copy_mode = UpdateCopyModeForMoonpie(moonpie_copy_mode);
+  ExpectCopyForSize(strlen(moonpie_text_) + kTrailingSpaces, moonpie_copy_mode);
+  ExpectAddress(FindMoonpieAddressForCopyMode(moonpie_copy_mode),
+                moonpie_copy_mode);
+}
+
+TEST_F(WeaselsToMoonpiesTest, EngineEncodeCompressibleNoTargetMatching) {
+  Encode(/* interleaved = */ true, /* target matching = */ false);
+  FindNextMoonpie(false);
+  // Expect all five "weasel"s to be replaced with "moon-pie"s
+  CopyBoilerplateAndAddMoonpie(default_cache_.FirstSameMode());
+  FindNextMoonpie(false);
+  CopyBoilerplateAndAddMoonpie(VCD_SELF_MODE);
+  FindNextMoonpie(false);
+  CopyBoilerplateAndAddMoonpie(default_cache_.FirstNearMode() + 1);
+  FindNextMoonpie(false);
+  CopyBoilerplateAndAddMoonpie(default_cache_.FirstNearMode() + 2);
+  FindNextMoonpie(false);
+  CopyBoilerplateAndAddMoonpie(default_cache_.FirstNearMode() + 3);
+  FindNextMoonpie(false);
+  EXPECT_TRUE(NoMoreMoonpies());
+  ExpectCopyForSize(strlen(dictionary_) - AfterLastWeasel(),
+                    default_cache_.FirstNearMode());
+  ExpectAddressVarintForSize(DistanceBetweenLastTwoWeasels());
+  VerifySizes();
+}
+
+TEST_F(WeaselsToMoonpiesTest, EngineEncodeCompressibleWithTargetMatching) {
+  Encode(/* interleaved = */ true, /* target matching = */ true);
+  // Expect all five "weasel"s to be replaced with "moon-pie"s.
+  // Every "moon-pie" after the first one should be copied from the
+  // previously encoded target text.
+  FindNextMoonpie(false);
+  CopyBoilerplateAndAddMoonpie(default_cache_.FirstSameMode());
+  FindNextMoonpie(true);
+  CopyBoilerplateAndCopyMoonpie(VCD_SELF_MODE, VCD_HERE_MODE);
+  if (kBlockSize <= 4) {
+    copied_moonpie_address_ = strlen(dictionary_) + LastMoonpiePosition();
+    FindNextMoonpie(true);
+    CopyBoilerplateAndCopyMoonpie(default_cache_.FirstNearMode() + 1,
+                                  default_cache_.FirstSameMode());
+  } else {  // kBlockSize > 4
+    copied_moonpie_address_ = strlen(dictionary_) + CurrentMoonpiePosition();
+    FindNextMoonpie(true);
+    CopyBoilerplateAndCopyMoonpie(default_cache_.FirstNearMode() + 1,
+                                  default_cache_.FirstNearMode() + 2);
+  }
+  LOG(INFO) << "copied_moonpie_address_ : "
+            << copied_moonpie_address_ << LOG_ENDL;
+  FindNextMoonpie(true);
+  CopyBoilerplateAndCopyMoonpie(default_cache_.FirstNearMode() + 3,
+                                default_cache_.FirstSameMode());
+  FindNextMoonpie(true);
+  CopyBoilerplateAndCopyMoonpie(default_cache_.FirstNearMode() + 1,
+                                default_cache_.FirstSameMode());
+  FindNextMoonpie(true);
+  EXPECT_TRUE(NoMoreMoonpies());
+  ExpectCopyForSize(strlen(dictionary_) - AfterLastWeasel(),
+                    default_cache_.FirstNearMode() + 3);
+  ExpectAddressVarintForSize(DistanceBetweenLastTwoWeasels());
+  VerifySizes();
+}
+
+}  //  anonymous namespace
+}  //  namespace open-vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcencoder.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcencoder.cc
new file mode 100644
index 0000000..94c883d
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcencoder.cc
@@ -0,0 +1,224 @@
+// Copyright 2007 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Classes to implement an Encoder for the format described in
+// RFC 3284 - The VCDIFF Generic Differencing and Compression Data Format.
+// The RFC text can be found at http://www.faqs.org/rfcs/rfc3284.html
+//
+// The RFC describes the possibility of using a secondary compressor
+// to further reduce the size of each section of the VCDIFF output.
+// That feature is not supported in this implementation of the encoder
+// and decoder.
+// No secondary compressor types have been publicly registered with
+// the IANA at http://www.iana.org/assignments/vcdiff-comp-ids
+// in the more than five years since the registry was created, so there
+// is no standard set of compressor IDs which would be generated by other
+// encoders or accepted by other decoders.
+
+#include <config.h>
+#include "google/vcencoder.h"
+#include <vector>
+#include "checksum.h"
+#include "encodetable.h"
+#include "logging.h"
+#include "google/output_string.h"
+#include "vcdiffengine.h"
+
+namespace open_vcdiff {
+
+HashedDictionary::HashedDictionary(const char* dictionary_contents,
+                                   size_t dictionary_size)
+    : engine_(new VCDiffEngine(dictionary_contents, dictionary_size)) { }
+
+HashedDictionary::~HashedDictionary() { delete engine_; }
+
+bool HashedDictionary::Init() {
+  return const_cast<VCDiffEngine*>(engine_)->Init();
+}
+
+class VCDiffStreamingEncoderImpl {
+ public:
+  VCDiffStreamingEncoderImpl(const HashedDictionary* dictionary,
+                             VCDiffFormatExtensionFlags format_extensions,
+                             bool look_for_target_matches);
+
+  // These functions are identical to their counterparts
+  // in VCDiffStreamingEncoder.
+  bool StartEncoding(OutputStringInterface* out);
+
+  bool EncodeChunk(const char* data, size_t len, OutputStringInterface* out);
+
+  bool FinishEncoding(OutputStringInterface* out);
+
+  const std::vector<int>& match_counts() const {
+    return coder_.match_counts();
+  }
+
+ private:
+  // Write the header (as defined in section 4.1 of the RFC) to *output.
+  // This includes information that can be gathered
+  // before the first chunk of input is available.
+  void WriteHeader(OutputStringInterface* output) const;
+
+  const VCDiffEngine* engine_;
+
+  // This implementation of the encoder uses the default
+  // code table.  A VCDiffCodeTableWriter could also be constructed
+  // using a custom code table.
+  VCDiffCodeTableWriter coder_;
+
+  const VCDiffFormatExtensionFlags format_extensions_;
+
+  // Determines whether to look for matches within the previously encoded
+  // target data, or just within the source (dictionary) data.  Please see
+  // vcencoder.h for a full explanation of this parameter.
+  const bool look_for_target_matches_;
+
+  // This state variable is used to ensure that StartEncoding(), EncodeChunk(),
+  // and FinishEncoding() are called in the correct order.  It will be true
+  // if StartEncoding() has been called, followed by zero or more calls to
+  // EncodeChunk(), but FinishEncoding() has not yet been called.  It will
+  // be false initially, and also after FinishEncoding() has been called.
+  bool encode_chunk_allowed_;
+
+  // Making these private avoids implicit copy constructor & assignment operator
+  VCDiffStreamingEncoderImpl(const VCDiffStreamingEncoderImpl&);  // NOLINT
+  void operator=(const VCDiffStreamingEncoderImpl&);
+};
+
+inline VCDiffStreamingEncoderImpl::VCDiffStreamingEncoderImpl(
+    const HashedDictionary* dictionary,
+    VCDiffFormatExtensionFlags format_extensions,
+    bool look_for_target_matches)
+    : engine_(dictionary->engine()),
+      coder_((format_extensions & VCD_FORMAT_INTERLEAVED) != 0),
+      format_extensions_(format_extensions),
+      look_for_target_matches_(look_for_target_matches),
+      encode_chunk_allowed_(false) { }
+
+inline void VCDiffStreamingEncoderImpl::WriteHeader(
+    OutputStringInterface* output) const {
+  DeltaFileHeader header_data = {
+    0xD6,  // Header1: "V" | 0x80
+    0xC3,  // Header2: "C" | 0x80
+    0xC4,  // Header3: "D" | 0x80
+    0x00,  // Header4: Draft standard format
+    0x00 };  // Hdr_Indicator:
+             // No compression, no custom code table
+  if (format_extensions_ != VCD_STANDARD_FORMAT) {
+    header_data.header4 = 'S';  // Header4: VCDIFF/SDCH, extensions used
+  }
+  output->append(reinterpret_cast<const char*>(&header_data),
+                 sizeof(header_data));
+  // If custom cache table sizes or a custom code table were used
+  // for encoding, here is where they would be appended to *output.
+  // This implementation of the encoder does not use those features,
+  // although the decoder can understand and interpret them.
+}
+
+inline bool VCDiffStreamingEncoderImpl::StartEncoding(
+    OutputStringInterface* out) {
+  WriteHeader(out);
+  encode_chunk_allowed_ = true;
+  return true;
+}
+
+inline bool VCDiffStreamingEncoderImpl::EncodeChunk(
+    const char* data,
+    size_t len,
+    OutputStringInterface* out) {
+  if (!encode_chunk_allowed_) {
+    LOG(ERROR) << "EncodeChunk called before StartEncoding" << LOG_ENDL;
+    return false;
+  }
+  if ((format_extensions_ & VCD_FORMAT_CHECKSUM) != 0) {
+    coder_.AddChecksum(ComputeAdler32(data, len));
+  }
+  engine_->Encode(data, len, look_for_target_matches_, out, &coder_);
+  return true;
+}
+
+inline bool VCDiffStreamingEncoderImpl::FinishEncoding(
+    OutputStringInterface* /*out*/) {
+  if (!encode_chunk_allowed_) {
+    LOG(ERROR) << "FinishEncoding called before StartEncoding" << LOG_ENDL;
+    return false;
+  }
+  encode_chunk_allowed_ = false;
+  // There should not be any need to output more data
+  // since EncodeChunk() encodes a complete target window
+  // and there is no end-of-delta-file marker.
+  return true;
+}
+
+VCDiffStreamingEncoder::VCDiffStreamingEncoder(
+    const HashedDictionary* dictionary,
+    VCDiffFormatExtensionFlags format_extensions,
+    bool look_for_target_matches)
+    : impl_(new VCDiffStreamingEncoderImpl(dictionary,
+                                           format_extensions,
+                                           look_for_target_matches)) { }
+
+VCDiffStreamingEncoder::~VCDiffStreamingEncoder() { delete impl_; }
+
+bool VCDiffStreamingEncoder::StartEncodingToInterface(
+    OutputStringInterface* out) {
+  return impl_->StartEncoding(out);
+}
+
+bool VCDiffStreamingEncoder::EncodeChunkToInterface(
+    const char* data,
+    size_t len,
+    OutputStringInterface* out) {
+  return impl_->EncodeChunk(data, len, out);
+}
+
+bool VCDiffStreamingEncoder::FinishEncodingToInterface(
+    OutputStringInterface* out) {
+  return impl_->FinishEncoding(out);
+}
+
+void VCDiffStreamingEncoder::GetMatchCounts(
+    std::vector<int>* match_counts) const {
+  if (!match_counts) {
+    LOG(DFATAL) << "GetMatchCounts() called with NULL argument" << LOG_ENDL;
+    return;
+  }
+  *match_counts = impl_->match_counts();
+}
+
+bool VCDiffEncoder::EncodeToInterface(const char* target_data,
+                                      size_t target_len,
+                                      OutputStringInterface* out) {
+  out->clear();
+  if (!encoder_) {
+    if (!dictionary_.Init()) {
+      LOG(ERROR) << "Error initializing HashedDictionary" << LOG_ENDL;
+      return false;
+    }
+    encoder_ = new VCDiffStreamingEncoder(&dictionary_,
+                                          flags_,
+                                          look_for_target_matches_);
+  }
+  if (!encoder_->StartEncodingToInterface(out)) {
+    return false;
+  }
+  if (!encoder_->EncodeChunkToInterface(target_data, target_len, out)) {
+    return false;
+  }
+  return encoder_->FinishEncodingToInterface(out);
+}
+
+}  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcencoder_test.cc b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcencoder_test.cc
new file mode 100644
index 0000000..500e799
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/vcencoder_test.cc
@@ -0,0 +1,948 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <config.h>
+#include "google/vcencoder.h"
+#include <algorithm>
+#include <cstdlib>  // free, posix_memalign
+#include <cstring>  // memcpy
+#include <string>
+#include <vector>
+#include "blockhash.h"
+#include "checksum.h"
+#include "logging.h"
+#include "google/output_string.h"
+#include "testing.h"
+#include "varint_bigendian.h"
+#include "google/vcdecoder.h"
+#include "vcdiff_defs.h"
+
+#ifdef HAVE_EXT_ROPE
+#include <ext/rope>
+#include "output_string_crope.h"
+using __gnu_cxx::crope;
+#endif  // HAVE_EXT_ROPE
+
+#ifdef HAVE_MALLOC_H
+#include <malloc.h>
+#endif  // HAVE_MALLOC_H
+
+#ifdef HAVE_SYS_MMAN_H
+#define _XOPEN_SOURCE 600  // posix_memalign
+#include <sys/mman.h>  // mprotect
+#endif  // HAVE_SYS_MMAN_H
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>  // getpagesize
+#endif  // HAVE_UNISTD_H
+
+namespace open_vcdiff {
+namespace {
+
+using std::string;
+
+static const size_t kFileHeaderSize = sizeof(DeltaFileHeader);
+
+// This is to check the maximum possible encoding size
+// if using a single ADD instruction, so assume that the
+// dictionary size, the length of the ADD data, the size
+// of the target window, and the length of the delta window
+// are all two-byte Varints, that is, 128 <= length < 4096.
+// This figure includes three extra bytes for a zero-sized
+// ADD instruction with a two-byte Varint explicit size.
+// Any additional COPY & ADD instructions must reduce
+// the length of the encoding from this maximum.
+static const size_t kWindowHeaderSize = 21;
+
+class VerifyEncodedBytesTest : public testing::Test {
+ public:
+  VerifyEncodedBytesTest() : delta_index_(0) { }
+  virtual ~VerifyEncodedBytesTest() { }
+
+  void ExpectByte(unsigned char b) {
+    EXPECT_EQ(b, static_cast<unsigned char>(delta_[delta_index_]));
+    ++delta_index_;
+  }
+
+  void ExpectString(const char* s) {
+    const size_t size = strlen(s);  // don't include terminating NULL char
+    EXPECT_EQ(string(s, size),
+              string(delta_data() + delta_index_, size));
+    delta_index_ += size;
+  }
+
+  void ExpectNoMoreBytes() {
+    EXPECT_EQ(delta_index_, delta_size());
+  }
+
+  void ExpectSize(size_t size) {
+    const char* delta_size_pos = &delta_[delta_index_];
+    EXPECT_EQ(size,
+              static_cast<size_t>(
+                  VarintBE<int32_t>::Parse(delta_data() + delta_size(),
+                                           &delta_size_pos)));
+    delta_index_ = delta_size_pos - delta_data();
+  }
+
+  void ExpectChecksum(VCDChecksum checksum) {
+    const char* delta_checksum_pos = &delta_[delta_index_];
+    EXPECT_EQ(checksum,
+              static_cast<VCDChecksum>(
+                  VarintBE<int64_t>::Parse(delta_data() + delta_size(),
+                                           &delta_checksum_pos)));
+    delta_index_ = delta_checksum_pos - delta_data();
+  }
+
+  const string& delta_as_const() const { return delta_; }
+  string* delta() { return &delta_; }
+
+  const char* delta_data() const { return delta_as_const().data(); }
+  size_t delta_size() const { return delta_as_const().size(); }
+
+ private:
+  string delta_;
+  size_t delta_index_;
+};
+
+class VCDiffEncoderTest : public VerifyEncodedBytesTest {
+ protected:
+  static const char kDictionary[];
+  static const char kTarget[];
+
+  VCDiffEncoderTest();
+  virtual ~VCDiffEncoderTest() { }
+
+  void TestWithFixedChunkSize(size_t chunk_size);
+  void TestWithEncodedChunkVector(size_t chunk_size);
+
+  HashedDictionary hashed_dictionary_;
+  VCDiffStreamingEncoder encoder_;
+  VCDiffStreamingDecoder decoder_;
+  VCDiffEncoder simple_encoder_;
+  VCDiffDecoder simple_decoder_;
+
+  string result_target_;
+};
+
+const char VCDiffEncoderTest::kDictionary[] =
+    "\"Just the place for a Snark!\" the Bellman cried,\n"
+    "As he landed his crew with care;\n"
+    "Supporting each man on the top of the tide\n"
+    "By a finger entwined in his hair.\n";
+
+const char VCDiffEncoderTest::kTarget[] =
+    "\"Just the place for a Snark! I have said it twice:\n"
+    "That alone should encourage the crew.\n"
+    "Just the place for a Snark! I have said it thrice:\n"
+    "What I tell you three times is true.\"\n";
+
+VCDiffEncoderTest::VCDiffEncoderTest()
+    : hashed_dictionary_(kDictionary, sizeof(kDictionary)),
+      encoder_(&hashed_dictionary_,
+               VCD_FORMAT_INTERLEAVED | VCD_FORMAT_CHECKSUM,
+               /* look_for_target_matches = */ true),
+      simple_encoder_(kDictionary, sizeof(kDictionary)) {
+  EXPECT_TRUE(hashed_dictionary_.Init());
+}
+
+TEST_F(VCDiffEncoderTest, EncodeBeforeStartEncoding) {
+  EXPECT_FALSE(encoder_.EncodeChunk(kTarget, strlen(kTarget), delta()));
+}
+
+TEST_F(VCDiffEncoderTest, FinishBeforeStartEncoding) {
+  EXPECT_FALSE(encoder_.FinishEncoding(delta()));
+}
+
+TEST_F(VCDiffEncoderTest, EncodeDecodeNothing) {
+  HashedDictionary nothing_dictionary("", 0);
+  EXPECT_TRUE(nothing_dictionary.Init());
+  VCDiffStreamingEncoder nothing_encoder(&nothing_dictionary,
+                                         VCD_STANDARD_FORMAT,
+                                         false);
+  EXPECT_TRUE(nothing_encoder.StartEncoding(delta()));
+  EXPECT_TRUE(nothing_encoder.FinishEncoding(delta()));
+  decoder_.StartDecoding("", 0);
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_data(),
+                                   delta_size(),
+                                   &result_target_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_TRUE(result_target_.empty());
+}
+
+// A NULL dictionary pointer is legal as long as the dictionary size is 0.
+TEST_F(VCDiffEncoderTest, EncodeDecodeNullDictionaryPtr) {
+  HashedDictionary null_dictionary(NULL, 0);
+  EXPECT_TRUE(null_dictionary.Init());
+  VCDiffStreamingEncoder null_encoder(&null_dictionary,
+                                      VCD_STANDARD_FORMAT,
+                                      false);
+  EXPECT_TRUE(null_encoder.StartEncoding(delta()));
+  EXPECT_TRUE(null_encoder.EncodeChunk(kTarget, strlen(kTarget), delta()));
+  EXPECT_TRUE(null_encoder.FinishEncoding(delta()));
+  EXPECT_GE(strlen(kTarget) + kFileHeaderSize + kWindowHeaderSize,
+            delta_size());
+  decoder_.StartDecoding(NULL, 0);
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_data(),
+                                   delta_size(),
+                                   &result_target_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(kTarget, result_target_);
+}
+
+TEST_F(VCDiffEncoderTest, EncodeDecodeSimple) {
+  EXPECT_TRUE(simple_encoder_.Encode(kTarget, strlen(kTarget), delta()));
+  EXPECT_GE(strlen(kTarget) + kFileHeaderSize + kWindowHeaderSize,
+            delta_size());
+  EXPECT_TRUE(simple_decoder_.Decode(kDictionary,
+                                     sizeof(kDictionary),
+                                     delta_as_const(),
+                                     &result_target_));
+  EXPECT_EQ(kTarget, result_target_);
+}
+
+TEST_F(VCDiffEncoderTest, EncodeDecodeInterleaved) {
+  simple_encoder_.SetFormatFlags(VCD_FORMAT_INTERLEAVED);
+  EXPECT_TRUE(simple_encoder_.Encode(kTarget, strlen(kTarget), delta()));
+  EXPECT_GE(strlen(kTarget) + kFileHeaderSize + kWindowHeaderSize,
+            delta_size());
+  EXPECT_TRUE(simple_decoder_.Decode(kDictionary,
+                                     sizeof(kDictionary),
+                                     delta_as_const(),
+                                     &result_target_));
+  EXPECT_EQ(kTarget, result_target_);
+}
+
+TEST_F(VCDiffEncoderTest, EncodeDecodeInterleavedChecksum) {
+  simple_encoder_.SetFormatFlags(VCD_FORMAT_INTERLEAVED | VCD_FORMAT_CHECKSUM);
+  EXPECT_TRUE(simple_encoder_.Encode(kTarget,
+                                     strlen(kTarget),
+                                     delta()));
+  EXPECT_GE(strlen(kTarget) + kFileHeaderSize + kWindowHeaderSize,
+            delta_size());
+  EXPECT_TRUE(simple_decoder_.Decode(kDictionary,
+                                     sizeof(kDictionary),
+                                     delta_as_const(),
+                                     &result_target_));
+  EXPECT_EQ(kTarget, result_target_);
+}
+
+TEST_F(VCDiffEncoderTest, EncodeDecodeSingleChunk) {
+  EXPECT_TRUE(encoder_.StartEncoding(delta()));
+  EXPECT_TRUE(encoder_.EncodeChunk(kTarget, strlen(kTarget), delta()));
+  EXPECT_TRUE(encoder_.FinishEncoding(delta()));
+  EXPECT_GE(strlen(kTarget) + kFileHeaderSize + kWindowHeaderSize,
+            delta_size());
+  decoder_.StartDecoding(kDictionary, sizeof(kDictionary));
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_data(),
+                                   delta_size(),
+                                   &result_target_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(kTarget, result_target_);
+}
+
+TEST_F(VCDiffEncoderTest, EncodeDecodeSeparate) {
+  string delta_start, delta_encode, delta_finish;
+  EXPECT_TRUE(encoder_.StartEncoding(&delta_start));
+  EXPECT_TRUE(encoder_.EncodeChunk(kTarget, strlen(kTarget), &delta_encode));
+  EXPECT_TRUE(encoder_.FinishEncoding(&delta_finish));
+  EXPECT_GE(strlen(kTarget) + kFileHeaderSize + kWindowHeaderSize,
+            delta_start.size() + delta_encode.size() + delta_finish.size());
+  decoder_.StartDecoding(kDictionary, sizeof(kDictionary));
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_start.data(),
+                                   delta_start.size(),
+                                   &result_target_));
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_encode.data(),
+                                   delta_encode.size(),
+                                   &result_target_));
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_finish.data(),
+                                   delta_finish.size(),
+                                   &result_target_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(kTarget, result_target_);
+}
+
+#ifdef HAVE_EXT_ROPE
+// Test that the crope class can be used in place of a string for encoding
+// and decoding.
+TEST_F(VCDiffEncoderTest, EncodeDecodeCrope) {
+  crope delta_crope, result_crope;
+  EXPECT_TRUE(encoder_.StartEncoding(&delta_crope));
+  EXPECT_TRUE(encoder_.EncodeChunk(kTarget, strlen(kTarget), &delta_crope));
+  EXPECT_TRUE(encoder_.FinishEncoding(&delta_crope));
+  EXPECT_GE(strlen(kTarget) + kFileHeaderSize + kWindowHeaderSize,
+            delta_crope.size());
+  decoder_.StartDecoding(kDictionary, sizeof(kDictionary));
+  // crope can't guarantee that its characters are contiguous, so the decoding
+  // has to be done byte-by-byte.
+  for (crope::const_iterator it = delta_crope.begin();
+       it != delta_crope.end(); it++) {
+    const char this_char = *it;
+    EXPECT_TRUE(decoder_.DecodeChunk(&this_char, 1, &result_crope));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  crope expected_target(kTarget);
+  EXPECT_EQ(expected_target, result_crope);
+}
+#endif  // HAVE_EXT_ROPE
+
+void VCDiffEncoderTest::TestWithFixedChunkSize(size_t chunk_size) {
+  delta()->clear();
+  EXPECT_TRUE(encoder_.StartEncoding(delta()));
+  for (size_t chunk_start_index = 0;
+       chunk_start_index < strlen(kTarget);
+       chunk_start_index += chunk_size) {
+    size_t this_chunk_size = chunk_size;
+    const size_t bytes_available = strlen(kTarget) - chunk_start_index;
+    if (this_chunk_size > bytes_available) {
+      this_chunk_size = bytes_available;
+    }
+    EXPECT_TRUE(encoder_.EncodeChunk(&kTarget[chunk_start_index],
+                                     this_chunk_size,
+                                     delta()));
+  }
+  EXPECT_TRUE(encoder_.FinishEncoding(delta()));
+  const size_t num_windows = (strlen(kTarget) / chunk_size) + 1;
+  const size_t size_of_windows =
+      strlen(kTarget) + (kWindowHeaderSize * num_windows);
+  EXPECT_GE(kFileHeaderSize + size_of_windows, delta_size());
+  result_target_.clear();
+  decoder_.StartDecoding(kDictionary, sizeof(kDictionary));
+  for (size_t chunk_start_index = 0;
+       chunk_start_index < delta_size();
+       chunk_start_index += chunk_size) {
+    size_t this_chunk_size = chunk_size;
+    const size_t bytes_available = delta_size() - chunk_start_index;
+    if (this_chunk_size > bytes_available) {
+      this_chunk_size = bytes_available;
+    }
+    EXPECT_TRUE(decoder_.DecodeChunk(delta_data() + chunk_start_index,
+                                     this_chunk_size,
+                                     &result_target_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(kTarget, result_target_);
+  LOG(INFO) << "Finished testing chunk_size = " << chunk_size << LOG_ENDL;
+}
+
+TEST_F(VCDiffEncoderTest, EncodeDecodeFixedChunkSizes) {
+  // These specific chunk sizes have failed in the past
+  TestWithFixedChunkSize(6);
+  TestWithFixedChunkSize(45);
+  TestWithFixedChunkSize(60);
+
+  // Now loop through all possible chunk sizes
+  for (size_t chunk_size = 1; chunk_size < strlen(kTarget); ++chunk_size) {
+    TestWithFixedChunkSize(chunk_size);
+  }
+}
+
+// Splits the text to be encoded into fixed-size chunks.  Encodes each
+// chunk and puts it into a vector of strings.  Then decodes each string
+// in the vector and appends the result into result_target_.
+void VCDiffEncoderTest::TestWithEncodedChunkVector(size_t chunk_size) {
+  std::vector<string> encoded_chunks;
+  string this_encoded_chunk;
+  size_t total_chunk_size = 0;
+  EXPECT_TRUE(encoder_.StartEncoding(&this_encoded_chunk));
+  encoded_chunks.push_back(this_encoded_chunk);
+  total_chunk_size += this_encoded_chunk.size();
+  for (size_t chunk_start_index = 0;
+       chunk_start_index < strlen(kTarget);
+       chunk_start_index += chunk_size) {
+    size_t this_chunk_size = chunk_size;
+    const size_t bytes_available = strlen(kTarget) - chunk_start_index;
+    if (this_chunk_size > bytes_available) {
+      this_chunk_size = bytes_available;
+    }
+    this_encoded_chunk.clear();
+    EXPECT_TRUE(encoder_.EncodeChunk(&kTarget[chunk_start_index],
+                                     this_chunk_size,
+                                     &this_encoded_chunk));
+    encoded_chunks.push_back(this_encoded_chunk);
+    total_chunk_size += this_encoded_chunk.size();
+  }
+  this_encoded_chunk.clear();
+  EXPECT_TRUE(encoder_.FinishEncoding(&this_encoded_chunk));
+  encoded_chunks.push_back(this_encoded_chunk);
+  total_chunk_size += this_encoded_chunk.size();
+  const size_t num_windows = (strlen(kTarget) / chunk_size) + 1;
+  const size_t size_of_windows =
+      strlen(kTarget) + (kWindowHeaderSize * num_windows);
+  EXPECT_GE(kFileHeaderSize + size_of_windows, total_chunk_size);
+  result_target_.clear();
+  decoder_.StartDecoding(kDictionary, sizeof(kDictionary));
+  for (std::vector<string>::iterator it = encoded_chunks.begin();
+       it != encoded_chunks.end(); ++it) {
+    EXPECT_TRUE(decoder_.DecodeChunk(it->data(), it->size(), &result_target_));
+  }
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(kTarget, result_target_);
+  LOG(INFO) << "Finished testing chunk_size = " << chunk_size << LOG_ENDL;
+}
+
+TEST_F(VCDiffEncoderTest, EncodeDecodeStreamOfChunks) {
+  // Loop through all possible chunk sizes
+  for (size_t chunk_size = 1; chunk_size < strlen(kTarget); ++chunk_size) {
+    TestWithEncodedChunkVector(chunk_size);
+  }
+}
+
+// Verify that HashedDictionary stores a copy of the dictionary text,
+// rather than just storing a pointer to it.  If the dictionary buffer
+// is overwritten after creating a HashedDictionary from it, it shouldn't
+// affect an encoder that uses that HashedDictionary.
+TEST_F(VCDiffEncoderTest, DictionaryBufferOverwritten) {
+  string dictionary_copy(kDictionary, sizeof(kDictionary));
+  HashedDictionary hd_copy(dictionary_copy.data(), dictionary_copy.size());
+  EXPECT_TRUE(hd_copy.Init());
+  VCDiffStreamingEncoder copy_encoder(&hd_copy,
+                                      VCD_FORMAT_INTERLEAVED
+                                          | VCD_FORMAT_CHECKSUM,
+                                      /* look_for_target_matches = */ true);
+  // Produce a reference version of the encoded text.
+  string delta_before;
+  EXPECT_TRUE(copy_encoder.StartEncoding(&delta_before));
+  EXPECT_TRUE(copy_encoder.EncodeChunk(kTarget,
+                                       strlen(kTarget),
+                                       &delta_before));
+  EXPECT_TRUE(copy_encoder.FinishEncoding(&delta_before));
+  EXPECT_GE(strlen(kTarget) + kFileHeaderSize + kWindowHeaderSize,
+            delta_before.size());
+
+  // Overwrite the dictionary text with all 'Q' characters.
+  dictionary_copy.replace(0,
+                          dictionary_copy.size(),
+                          dictionary_copy.size(),
+                          'Q');
+  // When the encoder is used on the same target text after overwriting
+  // the dictionary, it should produce the same encoded output.
+  string delta_after;
+  EXPECT_TRUE(copy_encoder.StartEncoding(&delta_after));
+  EXPECT_TRUE(copy_encoder.EncodeChunk(kTarget, strlen(kTarget), &delta_after));
+  EXPECT_TRUE(copy_encoder.FinishEncoding(&delta_after));
+  EXPECT_EQ(delta_before, delta_after);
+}
+
+// Binary data test part 1: The dictionary and target data should not
+// be treated as NULL-terminated.  An embedded NULL should be handled like
+// any other byte of data.
+TEST_F(VCDiffEncoderTest, DictionaryHasEmbeddedNULLs) {
+  const char embedded_null_dictionary_text[] =
+      { 0x00, 0xFF, 0xFE, 0xFD, 0x00, 0xFD, 0xFE, 0xFF, 0x00, 0x03 };
+  const char embedded_null_target[] =
+      { 0xFD, 0x00, 0xFD, 0xFE, 0x03, 0x00, 0x01, 0x00 };
+  CHECK_EQ(10, sizeof(embedded_null_dictionary_text));
+  CHECK_EQ(8, sizeof(embedded_null_target));
+  HashedDictionary embedded_null_dictionary(embedded_null_dictionary_text,
+      sizeof(embedded_null_dictionary_text));
+  EXPECT_TRUE(embedded_null_dictionary.Init());
+  VCDiffStreamingEncoder embedded_null_encoder(&embedded_null_dictionary,
+      VCD_FORMAT_INTERLEAVED | VCD_FORMAT_CHECKSUM,
+      /* look_for_target_matches = */ true);
+  EXPECT_TRUE(embedded_null_encoder.StartEncoding(delta()));
+  EXPECT_TRUE(embedded_null_encoder.EncodeChunk(embedded_null_target,
+                                                sizeof(embedded_null_target),
+                                                delta()));
+  EXPECT_TRUE(embedded_null_encoder.FinishEncoding(delta()));
+  decoder_.StartDecoding(embedded_null_dictionary_text,
+                         sizeof(embedded_null_dictionary_text));
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_data(),
+                                   delta_size(),
+                                   &result_target_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(sizeof(embedded_null_target), result_target_.size());
+  EXPECT_EQ(string(embedded_null_target,
+                   sizeof(embedded_null_target)),
+            result_target_);
+}
+
+// Binary data test part 2: An embedded CR or LF should be handled like
+// any other byte of data.  No text-processing of the data should occur.
+TEST_F(VCDiffEncoderTest, DictionaryHasEmbeddedNewlines) {
+  const char embedded_null_dictionary_text[] =
+      { 0x0C, 0xFF, 0xFE, 0x0C, 0x00, 0x0A, 0xFE, 0xFF, 0x00, 0x0A };
+  const char embedded_null_target[] =
+      { 0x0C, 0x00, 0x0A, 0xFE, 0x03, 0x00, 0x0A, 0x00 };
+  CHECK_EQ(10, sizeof(embedded_null_dictionary_text));
+  CHECK_EQ(8, sizeof(embedded_null_target));
+  HashedDictionary embedded_null_dictionary(embedded_null_dictionary_text,
+      sizeof(embedded_null_dictionary_text));
+  EXPECT_TRUE(embedded_null_dictionary.Init());
+  VCDiffStreamingEncoder embedded_null_encoder(&embedded_null_dictionary,
+      VCD_FORMAT_INTERLEAVED | VCD_FORMAT_CHECKSUM,
+      /* look_for_target_matches = */ true);
+  EXPECT_TRUE(embedded_null_encoder.StartEncoding(delta()));
+  EXPECT_TRUE(embedded_null_encoder.EncodeChunk(embedded_null_target,
+                                                sizeof(embedded_null_target),
+                                                delta()));
+  EXPECT_TRUE(embedded_null_encoder.FinishEncoding(delta()));
+  decoder_.StartDecoding(embedded_null_dictionary_text,
+                         sizeof(embedded_null_dictionary_text));
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_data(),
+                                   delta_size(),
+                                   &result_target_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  EXPECT_EQ(sizeof(embedded_null_target), result_target_.size());
+  EXPECT_EQ(string(embedded_null_target,
+                   sizeof(embedded_null_target)),
+            result_target_);
+}
+
+TEST_F(VCDiffEncoderTest, UsingWideCharacters) {
+  const wchar_t wchar_dictionary_text[] =
+      L"\"Just the place for a Snark!\" the Bellman cried,\n"
+      L"As he landed his crew with care;\n"
+      L"Supporting each man on the top of the tide\n"
+      L"By a finger entwined in his hair.\n";
+
+  const wchar_t wchar_target[] =
+      L"\"Just the place for a Snark! I have said it twice:\n"
+      L"That alone should encourage the crew.\n"
+      L"Just the place for a Snark! I have said it thrice:\n"
+      L"What I tell you three times is true.\"\n";
+
+  HashedDictionary wchar_dictionary((const char*) wchar_dictionary_text,
+                                    sizeof(wchar_dictionary_text));
+  EXPECT_TRUE(wchar_dictionary.Init());
+  VCDiffStreamingEncoder wchar_encoder(&wchar_dictionary,
+                                       VCD_FORMAT_INTERLEAVED
+                                           | VCD_FORMAT_CHECKSUM,
+                                       /* look_for_target_matches = */ false);
+  EXPECT_TRUE(wchar_encoder.StartEncoding(delta()));
+  EXPECT_TRUE(wchar_encoder.EncodeChunk((const char*) wchar_target,
+                                        sizeof(wchar_target),
+                                        delta()));
+  EXPECT_TRUE(wchar_encoder.FinishEncoding(delta()));
+  decoder_.StartDecoding((const char*) wchar_dictionary_text,
+                         sizeof(wchar_dictionary_text));
+  EXPECT_TRUE(decoder_.DecodeChunk(delta_data(),
+                                   delta_size(),
+                                   &result_target_));
+  EXPECT_TRUE(decoder_.FinishDecoding());
+  const wchar_t* result_as_wchar = (const wchar_t*) result_target_.data();
+  EXPECT_EQ(wcslen(wchar_target), wcslen(result_as_wchar));
+  EXPECT_EQ(0, wcscmp(wchar_target, result_as_wchar));
+}
+
+#if defined(HAVE_MPROTECT) && \
+   (defined(HAVE_MEMALIGN) || defined(HAVE_POSIX_MEMALIGN))
+// Bug 1220602: Make sure the encoder doesn't read past the end of the input
+// buffer.
+TEST_F(VCDiffEncoderTest, ShouldNotReadPastEndOfBuffer) {
+  const size_t target_size = strlen(kTarget);
+
+  // Allocate two memory pages.
+  const int page_size = getpagesize();
+  void* two_pages = NULL;
+#ifdef HAVE_POSIX_MEMALIGN
+  posix_memalign(&two_pages, page_size, 2 * page_size);
+#else  // !HAVE_POSIX_MEMALIGN
+  two_pages = memalign(page_size, 2 * page_size);
+#endif  // HAVE_POSIX_MEMALIGN
+  char* const first_page = reinterpret_cast<char*>(two_pages);
+  char* const second_page = first_page + page_size;
+
+  // Place the target string at the end of the first page.
+  char* const target_with_guard = second_page - target_size;
+  memcpy(target_with_guard, kTarget, target_size);
+
+  // Make the second page unreadable.
+  mprotect(second_page, page_size, PROT_NONE);
+
+  // Now perform the encode operation, which will cause a segmentation fault
+  // if it reads past the end of the buffer.
+  EXPECT_TRUE(encoder_.StartEncoding(delta()));
+  EXPECT_TRUE(encoder_.EncodeChunk(target_with_guard, target_size, delta()));
+  EXPECT_TRUE(encoder_.FinishEncoding(delta()));
+
+  // Undo the mprotect.
+  mprotect(second_page, page_size, PROT_READ|PROT_WRITE);
+  free(two_pages);
+}
+
+TEST_F(VCDiffEncoderTest, ShouldNotReadPastBeginningOfBuffer) {
+  const size_t target_size = strlen(kTarget);
+
+  // Allocate two memory pages.
+  const int page_size = getpagesize();
+  void* two_pages = NULL;
+#ifdef HAVE_POSIX_MEMALIGN
+  posix_memalign(&two_pages, page_size, 2 * page_size);
+#else  // !HAVE_POSIX_MEMALIGN
+  two_pages = memalign(page_size, 2 * page_size);
+#endif  // HAVE_POSIX_MEMALIGN
+  char* const first_page = reinterpret_cast<char*>(two_pages);
+  char* const second_page = first_page + page_size;
+
+  // Make the first page unreadable.
+  mprotect(first_page, page_size, PROT_NONE);
+
+  // Place the target string at the beginning of the second page.
+  char* const target_with_guard = second_page;
+  memcpy(target_with_guard, kTarget, target_size);
+
+  // Now perform the encode operation, which will cause a segmentation fault
+  // if it reads past the beginning of the buffer.
+  EXPECT_TRUE(encoder_.StartEncoding(delta()));
+  EXPECT_TRUE(encoder_.EncodeChunk(target_with_guard, target_size, delta()));
+  EXPECT_TRUE(encoder_.FinishEncoding(delta()));
+
+  // Undo the mprotect.
+  mprotect(first_page, page_size, PROT_READ|PROT_WRITE);
+  free(two_pages);
+}
+#endif  // HAVE_MPROTECT && (HAVE_MEMALIGN || HAVE_POSIX_MEMALIGN)
+
+class VCDiffMatchCountTest : public VerifyEncodedBytesTest {
+ protected:
+  virtual ~VCDiffMatchCountTest() { }
+
+  void ExpectMatch(size_t match_size) {
+    if (match_size >= expected_match_counts_.size()) {
+      // Be generous to avoid resizing again
+      expected_match_counts_.resize(match_size * 2, 0);
+    }
+    ++expected_match_counts_[match_size];
+  }
+
+  void VerifyMatchCounts() {
+    EXPECT_TRUE(std::equal(expected_match_counts_.begin(),
+                           expected_match_counts_.end(),
+                           actual_match_counts_.begin()));
+  }
+
+  std::vector<int> expected_match_counts_;
+  std::vector<int> actual_match_counts_;
+};
+
+class VCDiffHTML1Test : public VCDiffMatchCountTest {
+ protected:
+  static const char kDictionary[];
+  static const char kTarget[];
+
+  VCDiffHTML1Test();
+  virtual ~VCDiffHTML1Test() { }
+
+  void SimpleEncode();
+  void StreamingEncode();
+
+  HashedDictionary hashed_dictionary_;
+  VCDiffStreamingEncoder encoder_;
+  VCDiffStreamingDecoder decoder_;
+  VCDiffEncoder simple_encoder_;
+  VCDiffDecoder simple_decoder_;
+
+  string result_target_;
+};
+
+const char VCDiffHTML1Test::kDictionary[] =
+    "<html><font color=red>This part from the dict</font><br>";
+
+const char VCDiffHTML1Test::kTarget[] =
+    "<html><font color=red>This part from the dict</font><br>\n"
+    "And this part is not...</html>";
+
+VCDiffHTML1Test::VCDiffHTML1Test()
+    : hashed_dictionary_(kDictionary, sizeof(kDictionary)),
+      encoder_(&hashed_dictionary_,
+               VCD_FORMAT_INTERLEAVED | VCD_FORMAT_CHECKSUM,
+               /* look_for_target_matches = */ true),
+      simple_encoder_(kDictionary, sizeof(kDictionary)) {
+  EXPECT_TRUE(hashed_dictionary_.Init());
+}
+
+void VCDiffHTML1Test::SimpleEncode() {
+  EXPECT_TRUE(simple_encoder_.Encode(kTarget, strlen(kTarget), delta()));
+  EXPECT_GE(strlen(kTarget) + kFileHeaderSize + kWindowHeaderSize,
+            delta_size());
+  EXPECT_TRUE(simple_decoder_.Decode(kDictionary,
+                                     sizeof(kDictionary),
+                                     delta_as_const(),
+                                     &result_target_));
+  EXPECT_EQ(kTarget, result_target_);
+}
+
+void VCDiffHTML1Test::StreamingEncode() {
+  EXPECT_TRUE(encoder_.StartEncoding(delta()));
+  EXPECT_TRUE(encoder_.EncodeChunk(kTarget, strlen(kTarget), delta()));
+  EXPECT_TRUE(encoder_.FinishEncoding(delta()));
+}
+
+TEST_F(VCDiffHTML1Test, CheckOutputOfSimpleEncoder) {
+  SimpleEncode();
+  // These values do not depend on the block size used for encoding
+  ExpectByte(0xD6);  // 'V' | 0x80
+  ExpectByte(0xC3);  // 'C' | 0x80
+  ExpectByte(0xC4);  // 'D' | 0x80
+  ExpectByte(0x00);  // Simple encoder never uses interleaved format
+  ExpectByte(0x00);  // Hdr_Indicator
+  ExpectByte(VCD_SOURCE);  // Win_Indicator: VCD_SOURCE (dictionary)
+  ExpectByte(sizeof(kDictionary));  // Dictionary length
+  ExpectByte(0x00);  // Source segment position: start of dictionary
+  if (BlockHash::kBlockSize == 2) {
+    // A very small block size will catch the "html>" match.
+    ExpectByte(0x1F);  // Length of the delta encoding
+    ExpectSize(strlen(kTarget));  // Size of the target window
+    ExpectByte(0x00);  // Delta_indicator (no compression)
+    ExpectByte(0x11);  // Length of the data section
+    ExpectByte(0x06);  // Length of the instructions section
+    ExpectByte(0x03);  // Length of the address section
+    // Data section
+    ExpectString("\nAnd t");      // Data for 1st ADD
+    ExpectString("is not...</");  // Data for 2nd ADD
+    // Instructions section
+    ExpectByte(0x73);  // COPY size 0 mode VCD_SAME(0)
+    ExpectByte(0x38);  // COPY size (56)
+    ExpectByte(0x07);  // ADD size 6
+    ExpectByte(0x19);  // COPY size 9 mode VCD_SELF
+    ExpectByte(0x0C);  // ADD size 11
+    ExpectByte(0x15);  // COPY size 5 mode VCD_SELF
+    // Address section
+    ExpectByte(0x00);  // COPY address (0) mode VCD_SAME(0)
+    ExpectByte(0x17);  // COPY address (23) mode VCD_SELF
+    ExpectByte(0x01);  // COPY address (1) mode VCD_SELF
+  } else if (BlockHash::kBlockSize < 16) {
+    // A medium block size will catch the "his part " match.
+    ExpectByte(0x22);  // Length of the delta encoding
+    ExpectSize(strlen(kTarget));  // Size of the target window
+    ExpectByte(0x00);  // Delta_indicator (no compression)
+    ExpectByte(0x16);  // Length of the data section
+    ExpectByte(0x05);  // Length of the instructions section
+    ExpectByte(0x02);  // Length of the address section
+    // Data section
+    ExpectString("\nAnd t");      // Data for 1st ADD
+    ExpectString("is not...</html>");  // Data for 2nd ADD
+    // Instructions section
+    ExpectByte(0x73);  // COPY size 0 mode VCD_SAME(0)
+    ExpectByte(0x38);  // COPY size (56)
+    ExpectByte(0x07);  // ADD size 6
+    ExpectByte(0x19);  // COPY size 9 mode VCD_SELF
+    ExpectByte(0x11);  // ADD size 16
+    // Address section
+    ExpectByte(0x00);  // COPY address (0) mode VCD_SAME(0)
+    ExpectByte(0x17);  // COPY address (23) mode VCD_SELF
+  } else if (BlockHash::kBlockSize <= 56) {
+    // Any block size up to 56 will catch the matching prefix string.
+    ExpectByte(0x29);  // Length of the delta encoding
+    ExpectSize(strlen(kTarget));  // Size of the target window
+    ExpectByte(0x00);  // Delta_indicator (no compression)
+    ExpectByte(0x1F);  // Length of the data section
+    ExpectByte(0x04);  // Length of the instructions section
+    ExpectByte(0x01);  // Length of the address section
+    ExpectString("\nAnd this part is not...</html>");  // Data for ADD
+    // Instructions section
+    ExpectByte(0x73);  // COPY size 0 mode VCD_SAME(0)
+    ExpectByte(0x38);  // COPY size (56)
+    ExpectByte(0x01);  // ADD size 0
+    ExpectByte(0x1F);  // Size of ADD (31)
+    // Address section
+    ExpectByte(0x00);  // COPY address (0) mode VCD_SAME(0)
+  } else {
+    // The matching string is 56 characters long, and the block size is
+    // 64 or greater, so no match should be found.
+    ExpectSize(strlen(kTarget) + 7);  // Delta encoding len
+    ExpectSize(strlen(kTarget));  // Size of the target window
+    ExpectByte(0x00);  // Delta_indicator (no compression)
+    ExpectSize(strlen(kTarget));  // Length of the data section
+    ExpectByte(0x02);  // Length of the instructions section
+    ExpectByte(0x00);  // Length of the address section
+    // Data section
+    ExpectString(kTarget);
+    ExpectByte(0x01);  // ADD size 0
+    ExpectSize(strlen(kTarget));
+  }
+  ExpectNoMoreBytes();
+}
+
+TEST_F(VCDiffHTML1Test, MatchCounts) {
+  StreamingEncode();
+  encoder_.GetMatchCounts(&actual_match_counts_);
+  if (BlockHash::kBlockSize == 2) {
+    // A very small block size will catch the "html>" match.
+    ExpectMatch(56);
+    ExpectMatch(9);
+    ExpectMatch(5);
+  } else if (BlockHash::kBlockSize < 16) {
+    // A medium block size will catch the "his part " match.
+    ExpectMatch(56);
+    ExpectMatch(9);
+  } else if (BlockHash::kBlockSize <= 56) {
+    // Any block size up to 56 will catch the matching prefix string.
+    ExpectMatch(56);
+  }
+  VerifyMatchCounts();
+}
+
+#ifdef GTEST_HAS_DEATH_TEST
+typedef VCDiffHTML1Test VCDiffHTML1DeathTest;
+
+TEST_F(VCDiffHTML1DeathTest, NullMatchCounts) {
+  EXPECT_DEBUG_DEATH(encoder_.GetMatchCounts(NULL), "GetMatchCounts");
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+class VCDiffHTML2Test : public VCDiffMatchCountTest {
+ protected:
+  static const char kDictionary[];
+  static const char kTarget[];
+
+  VCDiffHTML2Test();
+  virtual ~VCDiffHTML2Test() { }
+
+  void SimpleEncode();
+  void StreamingEncode();
+
+  HashedDictionary hashed_dictionary_;
+  VCDiffStreamingEncoder encoder_;
+  VCDiffStreamingDecoder decoder_;
+  VCDiffEncoder simple_encoder_;
+  VCDiffDecoder simple_decoder_;
+
+  string result_target_;
+};
+
+const char VCDiffHTML2Test::kDictionary[] = "10\nThis is a test";
+
+const char VCDiffHTML2Test::kTarget[] = "This is a test!!!\n";
+
+VCDiffHTML2Test::VCDiffHTML2Test()
+    : hashed_dictionary_(kDictionary, sizeof(kDictionary)),
+      encoder_(&hashed_dictionary_,
+               VCD_FORMAT_INTERLEAVED | VCD_FORMAT_CHECKSUM,
+               /* look_for_target_matches = */ true),
+      simple_encoder_(kDictionary, sizeof(kDictionary)) {
+  EXPECT_TRUE(hashed_dictionary_.Init());
+}
+
+void VCDiffHTML2Test::SimpleEncode() {
+  EXPECT_TRUE(simple_encoder_.Encode(kTarget, strlen(kTarget), delta()));
+  EXPECT_GE(strlen(kTarget) + kFileHeaderSize + kWindowHeaderSize,
+            delta_size());
+  EXPECT_TRUE(simple_decoder_.Decode(kDictionary,
+                                     sizeof(kDictionary),
+                                     delta_as_const(),
+                                     &result_target_));
+  EXPECT_EQ(kTarget, result_target_);
+}
+
+void VCDiffHTML2Test::StreamingEncode() {
+  EXPECT_TRUE(encoder_.StartEncoding(delta()));
+  EXPECT_TRUE(encoder_.EncodeChunk(kTarget, strlen(kTarget), delta()));
+  EXPECT_GE(strlen(kTarget) + kFileHeaderSize + kWindowHeaderSize,
+            delta_size());
+  EXPECT_TRUE(simple_decoder_.Decode(kDictionary,
+                                     sizeof(kDictionary),
+                                     delta_as_const(),
+                                     &result_target_));
+  EXPECT_EQ(kTarget, result_target_);
+}
+
+TEST_F(VCDiffHTML2Test, VerifyOutputOfSimpleEncoder) {
+  SimpleEncode();
+  // These values do not depend on the block size used for encoding
+  ExpectByte(0xD6);  // 'V' | 0x80
+  ExpectByte(0xC3);  // 'C' | 0x80
+  ExpectByte(0xC4);  // 'D' | 0x80
+  ExpectByte(0x00);  // Simple encoder never uses interleaved format
+  ExpectByte(0x00);  // Hdr_Indicator
+  ExpectByte(VCD_SOURCE);  // Win_Indicator: VCD_SOURCE (dictionary)
+  ExpectByte(sizeof(kDictionary));  // Dictionary length
+  ExpectByte(0x00);  // Source segment position: start of dictionary
+  if (BlockHash::kBlockSize <= 8) {
+    ExpectByte(12);  // Length of the delta encoding
+    ExpectSize(strlen(kTarget));  // Size of the target window
+    ExpectByte(0x00);  // Delta_indicator (no compression)
+    ExpectByte(0x04);  // Length of the data section
+    ExpectByte(0x02);  // Length of the instructions section
+    ExpectByte(0x01);  // Length of the address section
+    ExpectByte('!');
+    ExpectByte('!');
+    ExpectByte('!');
+    ExpectByte('\n');
+    ExpectByte(0x1E);  // COPY size 14 mode VCD_SELF
+    ExpectByte(0x05);  // ADD size 4
+    ExpectByte(0x03);  // COPY address (3) mode VCD_SELF
+  } else {
+    // Larger block sizes will not catch any matches.
+    ExpectSize(strlen(kTarget) + 7);  // Delta encoding len
+    ExpectSize(strlen(kTarget));  // Size of the target window
+    ExpectByte(0x00);  // Delta_indicator (no compression)
+    ExpectSize(strlen(kTarget));  // Length of the data section
+    ExpectByte(0x02);  // Length of the instructions section
+    ExpectByte(0x00);  // Length of the address section
+    // Data section
+    ExpectString(kTarget);
+    ExpectByte(0x01);  // ADD size 0
+    ExpectSize(strlen(kTarget));
+  }
+  ExpectNoMoreBytes();
+}
+
+TEST_F(VCDiffHTML2Test, VerifyOutputWithChecksum) {
+  StreamingEncode();
+  const VCDChecksum html2_checksum = ComputeAdler32(kTarget, strlen(kTarget));
+  CHECK_EQ(5, VarintBE<int64_t>::Length(html2_checksum));
+  // These values do not depend on the block size used for encoding
+  ExpectByte(0xD6);  // 'V' | 0x80
+  ExpectByte(0xC3);  // 'C' | 0x80
+  ExpectByte(0xC4);  // 'D' | 0x80
+  ExpectByte('S');  // Format extensions
+  ExpectByte(0x00);  // Hdr_Indicator
+  ExpectByte(VCD_SOURCE | VCD_CHECKSUM);  // Win_Indicator
+  ExpectByte(sizeof(kDictionary));  // Dictionary length
+  ExpectByte(0x00);  // Source segment position: start of dictionary
+  if (BlockHash::kBlockSize <= 8) {
+    ExpectByte(17);  // Length of the delta encoding
+    ExpectSize(strlen(kTarget));  // Size of the target window
+    ExpectByte(0x00);  // Delta_indicator (no compression)
+    ExpectByte(0x00);  // Length of the data section
+    ExpectByte(0x07);  // Length of the instructions section
+    ExpectByte(0x00);  // Length of the address section
+    ExpectChecksum(html2_checksum);
+    ExpectByte(0x1E);  // COPY size 14 mode VCD_SELF
+    ExpectByte(0x03);  // COPY address (3) mode VCD_SELF
+    ExpectByte(0x05);  // ADD size 4
+    ExpectByte('!');
+    ExpectByte('!');
+    ExpectByte('!');
+    ExpectByte('\n');
+  } else {
+    // Larger block sizes will not catch any matches.
+    ExpectSize(strlen(kTarget) + 12);  // Delta encoding len
+    ExpectSize(strlen(kTarget));  // Size of the target window
+    ExpectByte(0x00);  // Delta_indicator (no compression)
+    ExpectByte(0x00);  // Length of the data section
+    ExpectSize(0x02 + strlen(kTarget));  // Interleaved
+    ExpectByte(0x00);  // Length of the address section
+    ExpectChecksum(html2_checksum);
+    // Data section
+    ExpectByte(0x01);  // ADD size 0
+    ExpectSize(strlen(kTarget));
+    ExpectString(kTarget);
+  }
+  ExpectNoMoreBytes();
+}
+
+TEST_F(VCDiffHTML2Test, MatchCounts) {
+  StreamingEncode();
+  encoder_.GetMatchCounts(&actual_match_counts_);
+  if (BlockHash::kBlockSize <= 8) {
+    ExpectMatch(14);
+  }
+  VerifyMatchCounts();
+}
+
+}  // anonymous namespace
+}  // namespace open_vcdiff
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/zconf.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/zconf.h
new file mode 100644
index 0000000..a4a2115
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/zconf.h
@@ -0,0 +1,335 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ */
+#ifdef Z_PREFIX
+#  define deflateInit_          z_deflateInit_
+#  define deflate               z_deflate
+#  define deflateEnd            z_deflateEnd
+#  define inflateInit_          z_inflateInit_
+#  define inflate               z_inflate
+#  define inflateEnd            z_inflateEnd
+#  define deflateInit2_         z_deflateInit2_
+#  define deflateSetDictionary  z_deflateSetDictionary
+#  define deflateCopy           z_deflateCopy
+#  define deflateReset          z_deflateReset
+#  define deflateParams         z_deflateParams
+#  define deflateBound          z_deflateBound
+#  define deflatePrime          z_deflatePrime
+#  define inflateInit2_         z_inflateInit2_
+#  define inflateSetDictionary  z_inflateSetDictionary
+#  define inflateSync           z_inflateSync
+#  define inflateSyncPoint      z_inflateSyncPoint
+#  define inflateCopy           z_inflateCopy
+#  define inflateReset          z_inflateReset
+#  define inflateBack           z_inflateBack
+#  define inflateBackEnd        z_inflateBackEnd
+#  define compress              z_compress
+#  define compress2             z_compress2
+#  define compressBound         z_compressBound
+#  define uncompress            z_uncompress
+#  define adler32               z_adler32
+#  define crc32                 z_crc32
+#  define get_crc_table         z_get_crc_table
+#  define zError                z_zError
+
+#  define alloc_func            z_alloc_func
+#  define free_func             z_free_func
+#  define in_func               z_in_func
+#  define out_func              z_out_func
+#  define Byte                  z_Byte
+#  define uInt                  z_uInt
+#  define uLong                 z_uLong
+#  define Bytef                 z_Bytef
+#  define charf                 z_charf
+#  define intf                  z_intf
+#  define uIntf                 z_uIntf
+#  define uLongf                z_uLongf
+#  define voidpf                z_voidpf
+#  define voidp                 z_voidp
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+#  define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+#  define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+#  ifndef WIN32
+#    define WIN32
+#  endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#    ifndef SYS16BIT
+#      define SYS16BIT
+#    endif
+#  endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+#  ifndef STDC
+#    define STDC
+#  endif
+#  if __STDC_VERSION__ >= 199901L
+#    ifndef STDC99
+#      define STDC99
+#    endif
+#  endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+#  define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
+#  define STDC
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const       /* note: need a more gentle solution here */
+#  endif
+#endif
+
+/* Some Mac compilers merge all .h files incorrectly: */
+#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
+#  define NO_DUMMY_DECL
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+#  if defined(M_I86SM) || defined(M_I86MM)
+     /* MSC small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef _MSC_VER
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#  if (defined(__SMALL__) || defined(__MEDIUM__))
+     /* Turbo C small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef __BORLANDC__
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+   /* If building or using zlib as a DLL, define ZLIB_DLL.
+    * This is not mandatory, but it offers a little performance increase.
+    */
+#  ifdef ZLIB_DLL
+#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#      ifdef ZLIB_INTERNAL
+#        define ZEXTERN extern __declspec(dllexport)
+#      else
+#        define ZEXTERN extern __declspec(dllimport)
+#      endif
+#    endif
+#  endif  /* ZLIB_DLL */
+   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+    * define ZLIB_WINAPI.
+    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+    */
+#  ifdef ZLIB_WINAPI
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+     /* No need for _export, use ZLIB.DEF instead. */
+     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#    define ZEXPORT WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA WINAPIV
+#    else
+#      define ZEXPORTVA FAR CDECL
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  ifdef ZLIB_DLL
+#    ifdef ZLIB_INTERNAL
+#      define ZEXPORT   __declspec(dllexport)
+#      define ZEXPORTVA __declspec(dllexport)
+#    else
+#      define ZEXPORT   __declspec(dllimport)
+#      define ZEXPORTVA __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+
+#ifndef FAR
+#  define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void const *voidpc;
+   typedef void FAR   *voidpf;
+   typedef void       *voidp;
+#else
+   typedef Byte const *voidpc;
+   typedef Byte FAR   *voidpf;
+   typedef Byte       *voidp;
+#endif
+
+#ifndef WIN32
+#if 1           /* HAVE_UNISTD_H -- this line is updated by ./configure */
+#  include <sys/types.h> /* for off_t */
+#  include <unistd.h>    /* for SEEK_* and off_t */
+#  ifdef VMS
+#    include <unixio.h>   /* for off_t */
+#  endif
+#  define z_off_t off_t
+#endif
+#endif
+
+#ifndef SEEK_SET
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+#ifndef z_off_t
+#  define z_off_t long
+#endif
+
+#if defined(__OS400__)
+#  define NO_vsnprintf
+#endif
+
+#if defined(__MVS__)
+#  define NO_vsnprintf
+#  ifdef FAR
+#    undef FAR
+#  endif
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+#   pragma map(deflateInit_,"DEIN")
+#   pragma map(deflateInit2_,"DEIN2")
+#   pragma map(deflateEnd,"DEEND")
+#   pragma map(deflateBound,"DEBND")
+#   pragma map(inflateInit_,"ININ")
+#   pragma map(inflateInit2_,"ININ2")
+#   pragma map(inflateEnd,"INEND")
+#   pragma map(inflateSync,"INSY")
+#   pragma map(inflateSetDictionary,"INSEDI")
+#   pragma map(compressBound,"CMBND")
+#   pragma map(inflate_table,"INTABL")
+#   pragma map(inflate_fast,"INFA")
+#   pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/zlib.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/zlib.h
new file mode 100644
index 0000000..6f64b98
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/src/zlib.h
@@ -0,0 +1,1373 @@
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.2.3, July 18th, 2005
+
+  Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+
+  The data format used by the zlib library is described by RFCs (Request for
+  Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt
+  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+*/
+
+#ifndef ZLIB_H
+#define ZLIB_H
+
+#include "zconf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ZLIB_VERSION "1.2.3"
+#define ZLIB_VERNUM 0x1230
+
+/*
+     The 'zlib' compression library provides in-memory compression and
+  decompression functions, including integrity checks of the uncompressed
+  data.  This version of the library supports only one compression method
+  (deflation) but other algorithms will be added later and will have the same
+  stream interface.
+
+     Compression can be done in a single step if the buffers are large
+  enough (for example if an input file is mmap'ed), or can be done by
+  repeated calls of the compression function.  In the latter case, the
+  application must provide more input and/or consume the output
+  (providing more output space) before each call.
+
+     The compressed data format used by default by the in-memory functions is
+  the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
+  around a deflate stream, which is itself documented in RFC 1951.
+
+     The library also supports reading and writing files in gzip (.gz) format
+  with an interface similar to that of stdio using the functions that start
+  with "gz".  The gzip format is different from the zlib format.  gzip is a
+  gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
+
+     This library can optionally read and write gzip streams in memory as well.
+
+     The zlib format was designed to be compact and fast for use in memory
+  and on communications channels.  The gzip format was designed for single-
+  file compression on file systems, has a larger header than zlib to maintain
+  directory information, and uses a different, slower check method than zlib.
+
+     The library does not install any signal handler. The decoder checks
+  the consistency of the compressed data, so the library should never
+  crash even in case of corrupted input.
+*/
+
+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
+
+struct internal_state;
+
+typedef struct z_stream_s {
+    Bytef    *next_in;  /* next input byte */
+    uInt     avail_in;  /* number of bytes available at next_in */
+    uLong    total_in;  /* total nb of input bytes read so far */
+
+    Bytef    *next_out; /* next output byte should be put there */
+    uInt     avail_out; /* remaining free space at next_out */
+    uLong    total_out; /* total nb of bytes output so far */
+
+    char     *msg;      /* last error message, NULL if no error */
+    struct internal_state FAR *state; /* not visible by applications */
+
+    alloc_func zalloc;  /* used to allocate the internal state */
+    free_func  zfree;   /* used to free the internal state */
+    voidpf     opaque;  /* private data object passed to zalloc and zfree */
+
+    int     data_type;  /* best guess about the data type: binary or text */
+    uLong   adler;      /* adler32 value of the uncompressed data */
+    uLong   reserved;   /* reserved for future use */
+} z_stream;
+
+typedef z_stream FAR *z_streamp;
+
+/*
+     gzip header information passed to and from zlib routines.  See RFC 1952
+  for more details on the meanings of these fields.
+*/
+typedef struct gz_header_s {
+    int     text;       /* true if compressed data believed to be text */
+    uLong   time;       /* modification time */
+    int     xflags;     /* extra flags (not used when writing a gzip file) */
+    int     os;         /* operating system */
+    Bytef   *extra;     /* pointer to extra field or Z_NULL if none */
+    uInt    extra_len;  /* extra field length (valid if extra != Z_NULL) */
+    uInt    extra_max;  /* space at extra (only when reading header) */
+    Bytef   *name;      /* pointer to zero-terminated file name or Z_NULL */
+    uInt    name_max;   /* space at name (only when reading header) */
+    Bytef   *comment;   /* pointer to zero-terminated comment or Z_NULL */
+    uInt    comm_max;   /* space at comment (only when reading header) */
+    int     hcrc;       /* true if there was or will be a header crc */
+    int     done;       /* true when done reading gzip header (not used
+                           when writing a gzip file) */
+} gz_header;
+
+typedef gz_header FAR *gz_headerp;
+
+/*
+   The application must update next_in and avail_in when avail_in has
+   dropped to zero. It must update next_out and avail_out when avail_out
+   has dropped to zero. The application must initialize zalloc, zfree and
+   opaque before calling the init function. All other fields are set by the
+   compression library and must not be updated by the application.
+
+   The opaque value provided by the application will be passed as the first
+   parameter for calls of zalloc and zfree. This can be useful for custom
+   memory management. The compression library attaches no meaning to the
+   opaque value.
+
+   zalloc must return Z_NULL if there is not enough memory for the object.
+   If zlib is used in a multi-threaded application, zalloc and zfree must be
+   thread safe.
+
+   On 16-bit systems, the functions zalloc and zfree must be able to allocate
+   exactly 65536 bytes, but will not be required to allocate more than this
+   if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
+   pointers returned by zalloc for objects of exactly 65536 bytes *must*
+   have their offset normalized to zero. The default allocation function
+   provided by this library ensures this (see zutil.c). To reduce memory
+   requirements and avoid any allocation of 64K objects, at the expense of
+   compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
+
+   The fields total_in and total_out can be used for statistics or
+   progress reports. After compression, total_in holds the total size of
+   the uncompressed data and may be saved for use in the decompressor
+   (particularly if the decompressor wants to decompress everything in
+   a single step).
+*/
+
+                        /* constants */
+
+#define Z_NO_FLUSH      0
+#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
+#define Z_SYNC_FLUSH    2
+#define Z_FULL_FLUSH    3
+#define Z_FINISH        4
+#define Z_BLOCK         5
+/* Allowed flush values; see deflate() and inflate() below for details */
+
+#define Z_OK            0
+#define Z_STREAM_END    1
+#define Z_NEED_DICT     2
+#define Z_ERRNO        (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR   (-3)
+#define Z_MEM_ERROR    (-4)
+#define Z_BUF_ERROR    (-5)
+#define Z_VERSION_ERROR (-6)
+/* Return codes for the compression/decompression functions. Negative
+ * values are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION         0
+#define Z_BEST_SPEED             1
+#define Z_BEST_COMPRESSION       9
+#define Z_DEFAULT_COMPRESSION  (-1)
+/* compression levels */
+
+#define Z_FILTERED            1
+#define Z_HUFFMAN_ONLY        2
+#define Z_RLE                 3
+#define Z_FIXED               4
+#define Z_DEFAULT_STRATEGY    0
+/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY   0
+#define Z_TEXT     1
+#define Z_ASCII    Z_TEXT   /* for compatibility with 1.2.2 and earlier */
+#define Z_UNKNOWN  2
+/* Possible values of the data_type field (though see inflate()) */
+
+#define Z_DEFLATED   8
+/* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
+
+#define zlib_version zlibVersion()
+/* for compatibility with versions < 1.0.2 */
+
+                        /* basic functions */
+
+ZEXTERN const char * ZEXPORT zlibVersion OF((void));
+/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+   If the first character differs, the library code actually used is
+   not compatible with the zlib.h header file used by the application.
+   This check is automatically made by deflateInit and inflateInit.
+ */
+
+/*
+ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
+
+     Initializes the internal stream state for compression. The fields
+   zalloc, zfree and opaque must be initialized before by the caller.
+   If zalloc and zfree are set to Z_NULL, deflateInit updates them to
+   use default allocation functions.
+
+     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+   1 gives best speed, 9 gives best compression, 0 gives no compression at
+   all (the input data is simply copied a block at a time).
+   Z_DEFAULT_COMPRESSION requests a default compromise between speed and
+   compression (currently equivalent to level 6).
+
+     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if level is not a valid compression level,
+   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+   with the version assumed by the caller (ZLIB_VERSION).
+   msg is set to null if there is no error message.  deflateInit does not
+   perform any compression: this will be done by deflate().
+*/
+
+
+ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
+/*
+    deflate compresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full. It may introduce some
+  output latency (reading input without producing any output) except when
+  forced to flush.
+
+    The detailed semantics are as follows. deflate performs one or both of the
+  following actions:
+
+  - Compress more input starting at next_in and update next_in and avail_in
+    accordingly. If not all input can be processed (because there is not
+    enough room in the output buffer), next_in and avail_in are updated and
+    processing will resume at this point for the next call of deflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly. This action is forced if the parameter flush is non zero.
+    Forcing flush frequently degrades the compression ratio, so this parameter
+    should be set only when necessary (in interactive applications).
+    Some output may be provided even if flush is not set.
+
+  Before the call of deflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming
+  more output, and updating avail_in or avail_out accordingly; avail_out
+  should never be zero before the call. The application can consume the
+  compressed output when it wants, for example when the output buffer is full
+  (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
+  and with zero avail_out, it must be called again after making room in the
+  output buffer because there might be more output pending.
+
+    Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
+  decide how much data to accumualte before producing output, in order to
+  maximize compression.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+  flushed to the output buffer and the output is aligned on a byte boundary, so
+  that the decompressor can get all input data available so far. (In particular
+  avail_in is zero after the call if enough output space has been provided
+  before the call.)  Flushing may degrade compression for some compression
+  algorithms and so it should be used only when necessary.
+
+    If flush is set to Z_FULL_FLUSH, all output is flushed as with
+  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+  restart from this point if previous compressed data has been damaged or if
+  random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
+  compression.
+
+    If deflate returns with avail_out == 0, this function must be called again
+  with the same value of the flush parameter and more output space (updated
+  avail_out), until the flush is complete (deflate returns with non-zero
+  avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
+  avail_out is greater than six to avoid repeated flush markers due to
+  avail_out == 0 on return.
+
+    If the parameter flush is set to Z_FINISH, pending input is processed,
+  pending output is flushed and deflate returns with Z_STREAM_END if there
+  was enough output space; if deflate returns with Z_OK, this function must be
+  called again with Z_FINISH and more output space (updated avail_out) but no
+  more input data, until it returns with Z_STREAM_END or an error. After
+  deflate has returned Z_STREAM_END, the only possible operations on the
+  stream are deflateReset or deflateEnd.
+
+    Z_FINISH can be used immediately after deflateInit if all the compression
+  is to be done in a single step. In this case, avail_out must be at least
+  the value returned by deflateBound (see below). If deflate does not return
+  Z_STREAM_END, then it must be called again as described above.
+
+    deflate() sets strm->adler to the adler32 checksum of all input read
+  so far (that is, total_in bytes).
+
+    deflate() may update strm->data_type if it can make a good guess about
+  the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered
+  binary. This field is only for information purposes and does not affect
+  the compression algorithm in any manner.
+
+    deflate() returns Z_OK if some progress has been made (more input
+  processed or more output produced), Z_STREAM_END if all input has been
+  consumed and all output has been produced (only when flush is set to
+  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+  if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
+  (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not
+  fatal, and deflate() can be called again with more input and more output
+  space to continue compressing.
+*/
+
+
+ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any
+   pending output.
+
+     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+   prematurely (some input or output was discarded). In the error case,
+   msg may be set but then points to a static string (which must not be
+   deallocated).
+*/
+
+
+/*
+ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
+
+     Initializes the internal stream state for decompression. The fields
+   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
+   the caller. If next_in is not Z_NULL and avail_in is large enough (the exact
+   value depends on the compression method), inflateInit determines the
+   compression method from the zlib header and allocates all data structures
+   accordingly; otherwise the allocation will be deferred to the first call of
+   inflate.  If zalloc and zfree are set to Z_NULL, inflateInit updates them to
+   use default allocation functions.
+
+     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller.  msg is set to null if there is no error
+   message. inflateInit does not perform any decompression apart from reading
+   the zlib header if present: this will be done by inflate().  (So next_in and
+   avail_in may be modified, but next_out and avail_out are unchanged.)
+*/
+
+
+ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
+/*
+    inflate decompresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full. It may introduce
+  some output latency (reading input without producing any output) except when
+  forced to flush.
+
+  The detailed semantics are as follows. inflate performs one or both of the
+  following actions:
+
+  - Decompress more input starting at next_in and update next_in and avail_in
+    accordingly. If not all input can be processed (because there is not
+    enough room in the output buffer), next_in is updated and processing
+    will resume at this point for the next call of inflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly.  inflate() provides as much output as possible, until there
+    is no more input data or no more space in the output buffer (see below
+    about the flush parameter).
+
+  Before the call of inflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming
+  more output, and updating the next_* and avail_* values accordingly.
+  The application can consume the uncompressed output when it wants, for
+  example when the output buffer is full (avail_out == 0), or after each
+  call of inflate(). If inflate returns Z_OK and with zero avail_out, it
+  must be called again after making room in the output buffer because there
+  might be more output pending.
+
+    The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH,
+  Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much
+  output as possible to the output buffer. Z_BLOCK requests that inflate() stop
+  if and when it gets to the next deflate block boundary. When decoding the
+  zlib or gzip format, this will cause inflate() to return immediately after
+  the header and before the first block. When doing a raw inflate, inflate()
+  will go ahead and process the first block, and will return when it gets to
+  the end of that block, or when it runs out of data.
+
+    The Z_BLOCK option assists in appending to or combining deflate streams.
+  Also to assist in this, on return inflate() will set strm->data_type to the
+  number of unused bits in the last byte taken from strm->next_in, plus 64
+  if inflate() is currently decoding the last block in the deflate stream,
+  plus 128 if inflate() returned immediately after decoding an end-of-block
+  code or decoding the complete header up to just before the first byte of the
+  deflate stream. The end-of-block will not be indicated until all of the
+  uncompressed data from that block has been written to strm->next_out.  The
+  number of unused bits may in general be greater than seven, except when
+  bit 7 of data_type is set, in which case the number of unused bits will be
+  less than eight.
+
+    inflate() should normally be called until it returns Z_STREAM_END or an
+  error. However if all decompression is to be performed in a single step
+  (a single call of inflate), the parameter flush should be set to
+  Z_FINISH. In this case all pending input is processed and all pending
+  output is flushed; avail_out must be large enough to hold all the
+  uncompressed data. (The size of the uncompressed data may have been saved
+  by the compressor for this purpose.) The next operation on this stream must
+  be inflateEnd to deallocate the decompression state. The use of Z_FINISH
+  is never required, but can be used to inform inflate that a faster approach
+  may be used for the single inflate() call.
+
+     In this implementation, inflate() always flushes as much output as
+  possible to the output buffer, and always uses the faster approach on the
+  first call. So the only effect of the flush parameter in this implementation
+  is on the return value of inflate(), as noted below, or when it returns early
+  because Z_BLOCK is used.
+
+     If a preset dictionary is needed after this call (see inflateSetDictionary
+  below), inflate sets strm->adler to the adler32 checksum of the dictionary
+  chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
+  strm->adler to the adler32 checksum of all output produced so far (that is,
+  total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
+  below. At the end of the stream, inflate() checks that its computed adler32
+  checksum is equal to that saved by the compressor and returns Z_STREAM_END
+  only if the checksum is correct.
+
+    inflate() will decompress and check either zlib-wrapped or gzip-wrapped
+  deflate data.  The header type is detected automatically.  Any information
+  contained in the gzip header is not retained, so applications that need that
+  information should instead use raw inflate, see inflateInit2() below, or
+  inflateBack() and perform their own processing of the gzip header and
+  trailer.
+
+    inflate() returns Z_OK if some progress has been made (more input processed
+  or more output produced), Z_STREAM_END if the end of the compressed data has
+  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+  corrupted (input stream not conforming to the zlib format or incorrect check
+  value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
+  if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory,
+  Z_BUF_ERROR if no progress is possible or if there was not enough room in the
+  output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
+  inflate() can be called again with more input and more output space to
+  continue decompressing. If Z_DATA_ERROR is returned, the application may then
+  call inflateSync() to look for a good compression block if a partial recovery
+  of the data is desired.
+*/
+
+
+ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any
+   pending output.
+
+     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
+   was inconsistent. In the error case, msg may be set but then points to a
+   static string (which must not be deallocated).
+*/
+
+                        /* Advanced functions */
+
+/*
+    The following functions are needed only in some special applications.
+*/
+
+/*
+ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
+                                     int  level,
+                                     int  method,
+                                     int  windowBits,
+                                     int  memLevel,
+                                     int  strategy));
+
+     This is another version of deflateInit with more compression options. The
+   fields next_in, zalloc, zfree and opaque must be initialized before by
+   the caller.
+
+     The method parameter is the compression method. It must be Z_DEFLATED in
+   this version of the library.
+
+     The windowBits parameter is the base two logarithm of the window size
+   (the size of the history buffer). It should be in the range 8..15 for this
+   version of the library. Larger values of this parameter result in better
+   compression at the expense of memory usage. The default value is 15 if
+   deflateInit is used instead.
+
+     windowBits can also be -8..-15 for raw deflate. In this case, -windowBits
+   determines the window size. deflate() will then generate raw deflate data
+   with no zlib header or trailer, and will not compute an adler32 check value.
+
+     windowBits can also be greater than 15 for optional gzip encoding. Add
+   16 to windowBits to write a simple gzip header and trailer around the
+   compressed data instead of a zlib wrapper. The gzip header will have no
+   file name, no extra data, no comment, no modification time (set to zero),
+   no header crc, and the operating system will be set to 255 (unknown).  If a
+   gzip stream is being written, strm->adler is a crc32 instead of an adler32.
+
+     The memLevel parameter specifies how much memory should be allocated
+   for the internal compression state. memLevel=1 uses minimum memory but
+   is slow and reduces compression ratio; memLevel=9 uses maximum memory
+   for optimal speed. The default value is 8. See zconf.h for total memory
+   usage as a function of windowBits and memLevel.
+
+     The strategy parameter is used to tune the compression algorithm. Use the
+   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+   filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
+   string match), or Z_RLE to limit match distances to one (run-length
+   encoding). Filtered data consists mostly of small values with a somewhat
+   random distribution. In this case, the compression algorithm is tuned to
+   compress them better. The effect of Z_FILTERED is to force more Huffman
+   coding and less string matching; it is somewhat intermediate between
+   Z_DEFAULT and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as
+   Z_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy
+   parameter only affects the compression ratio but not the correctness of the
+   compressed output even if it is not set appropriately.  Z_FIXED prevents the
+   use of dynamic Huffman codes, allowing for a simpler decoder for special
+   applications.
+
+      deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
+   method). msg is set to null if there is no error message.  deflateInit2 does
+   not perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the compression dictionary from the given byte sequence
+   without producing any compressed output. This function must be called
+   immediately after deflateInit, deflateInit2 or deflateReset, before any
+   call of deflate. The compressor and decompressor must use exactly the same
+   dictionary (see inflateSetDictionary).
+
+     The dictionary should consist of strings (byte sequences) that are likely
+   to be encountered later in the data to be compressed, with the most commonly
+   used strings preferably put towards the end of the dictionary. Using a
+   dictionary is most useful when the data to be compressed is short and can be
+   predicted with good accuracy; the data can then be compressed better than
+   with the default empty dictionary.
+
+     Depending on the size of the compression data structures selected by
+   deflateInit or deflateInit2, a part of the dictionary may in effect be
+   discarded, for example if the dictionary is larger than the window size in
+   deflate or deflate2. Thus the strings most likely to be useful should be
+   put at the end of the dictionary, not at the front. In addition, the
+   current implementation of deflate will use at most the window size minus
+   262 bytes of the provided dictionary.
+
+     Upon return of this function, strm->adler is set to the adler32 value
+   of the dictionary; the decompressor may later use this value to determine
+   which dictionary has been used by the compressor. (The adler32 value
+   applies to the whole dictionary even if only a subset of the dictionary is
+   actually used by the compressor.) If a raw deflate was requested, then the
+   adler32 value is not computed and strm->adler is not set.
+
+     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+   parameter is invalid (such as NULL dictionary) or the stream state is
+   inconsistent (for example if deflate has already been called for this stream
+   or if the compression method is bsort). deflateSetDictionary does not
+   perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when several compression strategies will be
+   tried, for example when there are several ways of pre-processing the input
+   data with a filter. The streams that will be discarded should then be freed
+   by calling deflateEnd.  Note that deflateCopy duplicates the internal
+   compression state which can be quite large, so this strategy is slow and
+   can consume lots of memory.
+
+     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being NULL). msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to deflateEnd followed by deflateInit,
+   but does not free and reallocate all the internal compression state.
+   The stream will keep the same compression level and any other attributes
+   that may have been set by deflateInit2.
+
+      deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+                                      int level,
+                                      int strategy));
+/*
+     Dynamically update the compression level and compression strategy.  The
+   interpretation of level and strategy is as in deflateInit2.  This can be
+   used to switch between compression and straight copy of the input data, or
+   to switch to a different kind of input data requiring a different
+   strategy. If the compression level is changed, the input available so far
+   is compressed with the old level (and may be flushed); the new level will
+   take effect only at the next call of deflate().
+
+     Before the call of deflateParams, the stream state must be set as for
+   a call of deflate(), since the currently available input may have to
+   be compressed and flushed. In particular, strm->avail_out must be non-zero.
+
+     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
+   stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
+   if strm->avail_out was zero.
+*/
+
+ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
+                                    int good_length,
+                                    int max_lazy,
+                                    int nice_length,
+                                    int max_chain));
+/*
+     Fine tune deflate's internal compression parameters.  This should only be
+   used by someone who understands the algorithm used by zlib's deflate for
+   searching for the best matching string, and even then only by the most
+   fanatic optimizer trying to squeeze out the last compressed bit for their
+   specific input data.  Read the deflate.c source code for the meaning of the
+   max_lazy, good_length, nice_length, and max_chain parameters.
+
+     deflateTune() can be called after deflateInit() or deflateInit2(), and
+   returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
+ */
+
+ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
+                                       uLong sourceLen));
+/*
+     deflateBound() returns an upper bound on the compressed size after
+   deflation of sourceLen bytes.  It must be called after deflateInit()
+   or deflateInit2().  This would be used to allocate an output buffer
+   for deflation in a single pass, and so would be called before deflate().
+*/
+
+ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
+                                     int bits,
+                                     int value));
+/*
+     deflatePrime() inserts bits in the deflate output stream.  The intent
+  is that this function is used to start off the deflate output with the
+  bits leftover from a previous deflate stream when appending to it.  As such,
+  this function can only be used for raw deflate, and must be used before the
+  first deflate() call after a deflateInit2() or deflateReset().  bits must be
+  less than or equal to 16, and that many of the least significant bits of
+  value will be inserted in the output.
+
+      deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
+                                         gz_headerp head));
+/*
+      deflateSetHeader() provides gzip header information for when a gzip
+   stream is requested by deflateInit2().  deflateSetHeader() may be called
+   after deflateInit2() or deflateReset() and before the first call of
+   deflate().  The text, time, os, extra field, name, and comment information
+   in the provided gz_header structure are written to the gzip header (xflag is
+   ignored -- the extra flags are set according to the compression level).  The
+   caller must assure that, if not Z_NULL, name and comment are terminated with
+   a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
+   available there.  If hcrc is true, a gzip header crc is included.  Note that
+   the current versions of the command-line version of gzip (up through version
+   1.3.x) do not support header crc's, and will report that it is a "multi-part
+   gzip file" and give up.
+
+      If deflateSetHeader is not used, the default gzip header has text false,
+   the time set to zero, and os set to 255, with no extra, name, or comment
+   fields.  The gzip header is returned to the default state by deflateReset().
+
+      deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
+                                     int  windowBits));
+
+     This is another version of inflateInit with an extra parameter. The
+   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+   before by the caller.
+
+     The windowBits parameter is the base two logarithm of the maximum window
+   size (the size of the history buffer).  It should be in the range 8..15 for
+   this version of the library. The default value is 15 if inflateInit is used
+   instead. windowBits must be greater than or equal to the windowBits value
+   provided to deflateInit2() while compressing, or it must be equal to 15 if
+   deflateInit2() was not used. If a compressed stream with a larger window
+   size is given as input, inflate() will return with the error code
+   Z_DATA_ERROR instead of trying to allocate a larger window.
+
+     windowBits can also be -8..-15 for raw inflate. In this case, -windowBits
+   determines the window size. inflate() will then process raw deflate data,
+   not looking for a zlib or gzip header, not generating a check value, and not
+   looking for any check values for comparison at the end of the stream. This
+   is for use with other formats that use the deflate compressed data format
+   such as zip.  Those formats provide their own check values. If a custom
+   format is developed using the raw deflate format for compressed data, it is
+   recommended that a check value such as an adler32 or a crc32 be applied to
+   the uncompressed data as is done in the zlib, gzip, and zip formats.  For
+   most applications, the zlib format should be used as is. Note that comments
+   above on the use in deflateInit2() applies to the magnitude of windowBits.
+
+     windowBits can also be greater than 15 for optional gzip decoding. Add
+   32 to windowBits to enable zlib and gzip decoding with automatic header
+   detection, or add 16 to decode only the gzip format (the zlib format will
+   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is
+   a crc32 instead of an adler32.
+
+     inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if a parameter is invalid (such as a null strm). msg
+   is set to null if there is no error message.  inflateInit2 does not perform
+   any decompression apart from reading the zlib header if present: this will
+   be done by inflate(). (So next_in and avail_in may be modified, but next_out
+   and avail_out are unchanged.)
+*/
+
+ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the decompression dictionary from the given uncompressed byte
+   sequence. This function must be called immediately after a call of inflate,
+   if that call returned Z_NEED_DICT. The dictionary chosen by the compressor
+   can be determined from the adler32 value returned by that call of inflate.
+   The compressor and decompressor must use exactly the same dictionary (see
+   deflateSetDictionary).  For raw inflate, this function can be called
+   immediately after inflateInit2() or inflateReset() and before any call of
+   inflate() to set the dictionary.  The application must insure that the
+   dictionary that was used for compression is provided.
+
+     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+   parameter is invalid (such as NULL dictionary) or the stream state is
+   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+   expected one (incorrect adler32 value). inflateSetDictionary does not
+   perform any decompression: this will be done by subsequent calls of
+   inflate().
+*/
+
+ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
+/*
+    Skips invalid compressed data until a full flush point (see above the
+  description of deflate with Z_FULL_FLUSH) can be found, or until all
+  available input is skipped. No output is provided.
+
+    inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
+  if no more input was provided, Z_DATA_ERROR if no flush point has been found,
+  or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
+  case, the application may save the current current value of total_in which
+  indicates where valid compressed data was found. In the error case, the
+  application may repeatedly call inflateSync, providing more input each time,
+  until success or end of the input data.
+*/
+
+ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when randomly accessing a large stream.  The
+   first pass through the stream can periodically record the inflate state,
+   allowing restarting inflate at those points when randomly accessing the
+   stream.
+
+     inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being NULL). msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to inflateEnd followed by inflateInit,
+   but does not free and reallocate all the internal decompression state.
+   The stream will keep attributes that may have been set by inflateInit2.
+
+      inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
+                                     int bits,
+                                     int value));
+/*
+     This function inserts bits in the inflate input stream.  The intent is
+  that this function is used to start inflating at a bit position in the
+  middle of a byte.  The provided bits will be used before any bytes are used
+  from next_in.  This function should only be used with raw inflate, and
+  should be used before the first inflate() call after inflateInit2() or
+  inflateReset().  bits must be less than or equal to 16, and that many of the
+  least significant bits of value will be inserted in the input.
+
+      inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
+                                         gz_headerp head));
+/*
+      inflateGetHeader() requests that gzip header information be stored in the
+   provided gz_header structure.  inflateGetHeader() may be called after
+   inflateInit2() or inflateReset(), and before the first call of inflate().
+   As inflate() processes the gzip stream, head->done is zero until the header
+   is completed, at which time head->done is set to one.  If a zlib stream is
+   being decoded, then head->done is set to -1 to indicate that there will be
+   no gzip header information forthcoming.  Note that Z_BLOCK can be used to
+   force inflate() to return immediately after header processing is complete
+   and before any actual data is decompressed.
+
+      The text, time, xflags, and os fields are filled in with the gzip header
+   contents.  hcrc is set to true if there is a header CRC.  (The header CRC
+   was valid if done is set to one.)  If extra is not Z_NULL, then extra_max
+   contains the maximum number of bytes to write to extra.  Once done is true,
+   extra_len contains the actual extra field length, and extra contains the
+   extra field, or that field truncated if extra_max is less than extra_len.
+   If name is not Z_NULL, then up to name_max characters are written there,
+   terminated with a zero unless the length is greater than name_max.  If
+   comment is not Z_NULL, then up to comm_max characters are written there,
+   terminated with a zero unless the length is greater than comm_max.  When
+   any of extra, name, or comment are not Z_NULL and the respective field is
+   not present in the header, then that field is set to Z_NULL to signal its
+   absence.  This allows the use of deflateSetHeader() with the returned
+   structure to duplicate the header.  However if those fields are set to
+   allocated memory, then the application will need to save those pointers
+   elsewhere so that they can be eventually freed.
+
+      If inflateGetHeader is not used, then the header information is simply
+   discarded.  The header is always checked for validity, including the header
+   CRC if present.  inflateReset() will reset the process to discard the header
+   information.  The application would need to call inflateGetHeader() again to
+   retrieve the header from the next gzip stream.
+
+      inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
+                                        unsigned char FAR *window));
+
+     Initialize the internal stream state for decompression using inflateBack()
+   calls.  The fields zalloc, zfree and opaque in strm must be initialized
+   before the call.  If zalloc and zfree are Z_NULL, then the default library-
+   derived memory allocation routines are used.  windowBits is the base two
+   logarithm of the window size, in the range 8..15.  window is a caller
+   supplied buffer of that size.  Except for special applications where it is
+   assured that deflate was used with small window sizes, windowBits must be 15
+   and a 32K byte window must be supplied to be able to decompress general
+   deflate streams.
+
+     See inflateBack() for the usage of these routines.
+
+     inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
+   the paramaters are invalid, Z_MEM_ERROR if the internal state could not
+   be allocated, or Z_VERSION_ERROR if the version of the library does not
+   match the version of the header file.
+*/
+
+typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *));
+typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
+
+ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
+                                    in_func in, void FAR *in_desc,
+                                    out_func out, void FAR *out_desc));
+/*
+     inflateBack() does a raw inflate with a single call using a call-back
+   interface for input and output.  This is more efficient than inflate() for
+   file i/o applications in that it avoids copying between the output and the
+   sliding window by simply making the window itself the output buffer.  This
+   function trusts the application to not change the output buffer passed by
+   the output function, at least until inflateBack() returns.
+
+     inflateBackInit() must be called first to allocate the internal state
+   and to initialize the state with the user-provided window buffer.
+   inflateBack() may then be used multiple times to inflate a complete, raw
+   deflate stream with each call.  inflateBackEnd() is then called to free
+   the allocated state.
+
+     A raw deflate stream is one with no zlib or gzip header or trailer.
+   This routine would normally be used in a utility that reads zip or gzip
+   files and writes out uncompressed files.  The utility would decode the
+   header and process the trailer on its own, hence this routine expects
+   only the raw deflate stream to decompress.  This is different from the
+   normal behavior of inflate(), which expects either a zlib or gzip header and
+   trailer around the deflate stream.
+
+     inflateBack() uses two subroutines supplied by the caller that are then
+   called by inflateBack() for input and output.  inflateBack() calls those
+   routines until it reads a complete deflate stream and writes out all of the
+   uncompressed data, or until it encounters an error.  The function's
+   parameters and return types are defined above in the in_func and out_func
+   typedefs.  inflateBack() will call in(in_desc, &buf) which should return the
+   number of bytes of provided input, and a pointer to that input in buf.  If
+   there is no input available, in() must return zero--buf is ignored in that
+   case--and inflateBack() will return a buffer error.  inflateBack() will call
+   out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].  out()
+   should return zero on success, or non-zero on failure.  If out() returns
+   non-zero, inflateBack() will return with an error.  Neither in() nor out()
+   are permitted to change the contents of the window provided to
+   inflateBackInit(), which is also the buffer that out() uses to write from.
+   The length written by out() will be at most the window size.  Any non-zero
+   amount of input may be provided by in().
+
+     For convenience, inflateBack() can be provided input on the first call by
+   setting strm->next_in and strm->avail_in.  If that input is exhausted, then
+   in() will be called.  Therefore strm->next_in must be initialized before
+   calling inflateBack().  If strm->next_in is Z_NULL, then in() will be called
+   immediately for input.  If strm->next_in is not Z_NULL, then strm->avail_in
+   must also be initialized, and then if strm->avail_in is not zero, input will
+   initially be taken from strm->next_in[0 .. strm->avail_in - 1].
+
+     The in_desc and out_desc parameters of inflateBack() is passed as the
+   first parameter of in() and out() respectively when they are called.  These
+   descriptors can be optionally used to pass any information that the caller-
+   supplied in() and out() functions need to do their job.
+
+     On return, inflateBack() will set strm->next_in and strm->avail_in to
+   pass back any unused input that was provided by the last in() call.  The
+   return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
+   if in() or out() returned an error, Z_DATA_ERROR if there was a format
+   error in the deflate stream (in which case strm->msg is set to indicate the
+   nature of the error), or Z_STREAM_ERROR if the stream was not properly
+   initialized.  In the case of Z_BUF_ERROR, an input or output error can be
+   distinguished using strm->next_in which will be Z_NULL only if in() returned
+   an error.  If strm->next is not Z_NULL, then the Z_BUF_ERROR was due to
+   out() returning non-zero.  (in() will always be called before out(), so
+   strm->next_in is assured to be defined if out() returns non-zero.)  Note
+   that inflateBack() cannot return Z_OK.
+*/
+
+ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
+/*
+     All memory allocated by inflateBackInit() is freed.
+
+     inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
+   state was inconsistent.
+*/
+
+ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
+/* Return flags indicating compile-time options.
+
+    Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
+     1.0: size of uInt
+     3.2: size of uLong
+     5.4: size of voidpf (pointer)
+     7.6: size of z_off_t
+
+    Compiler, assembler, and debug options:
+     8: DEBUG
+     9: ASMV or ASMINF -- use ASM code
+     10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
+     11: 0 (reserved)
+
+    One-time table building (smaller code, but not thread-safe if true):
+     12: BUILDFIXED -- build static block decoding tables when needed
+     13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
+     14,15: 0 (reserved)
+
+    Library content (indicates missing functionality):
+     16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
+                          deflate code when not needed)
+     17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
+                    and decode gzip streams (to avoid linking crc code)
+     18-19: 0 (reserved)
+
+    Operation variations (changes in library functionality):
+     20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
+     21: FASTEST -- deflate algorithm with only one, lowest compression level
+     22,23: 0 (reserved)
+
+    The sprintf variant used by gzprintf (zero is best):
+     24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
+     25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
+     26: 0 = returns value, 1 = void -- 1 means inferred string length returned
+
+    Remainder:
+     27-31: 0 (reserved)
+ */
+
+
+                        /* utility functions */
+
+/*
+     The following utility functions are implemented on top of the
+   basic stream-oriented functions. To simplify the interface, some
+   default options are assumed (compression level and memory usage,
+   standard memory allocation functions). The source code of these
+   utility functions can easily be modified if you need special options.
+*/
+
+ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
+                                 const Bytef *source, uLong sourceLen));
+/*
+     Compresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer. Upon entry, destLen is the total
+   size of the destination buffer, which must be at least the value returned
+   by compressBound(sourceLen). Upon exit, destLen is the actual size of the
+   compressed buffer.
+     This function can be used to compress a whole file at once if the
+   input file is mmap'ed.
+     compress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer.
+*/
+
+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
+                                  const Bytef *source, uLong sourceLen,
+                                  int level));
+/*
+     Compresses the source buffer into the destination buffer. The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer. Upon entry, destLen is the total size of the
+   destination buffer, which must be at least the value returned by
+   compressBound(sourceLen). Upon exit, destLen is the actual size of the
+   compressed buffer.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+
+ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
+/*
+     compressBound() returns an upper bound on the compressed size after
+   compress() or compress2() on sourceLen bytes.  It would be used before
+   a compress() or compress2() call to allocate the destination buffer.
+*/
+
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
+                                   const Bytef *source, uLong sourceLen));
+/*
+     Decompresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer. Upon entry, destLen is the total
+   size of the destination buffer, which must be large enough to hold the
+   entire uncompressed data. (The size of the uncompressed data must have
+   been saved previously by the compressor and transmitted to the decompressor
+   by some mechanism outside the scope of this compression library.)
+   Upon exit, destLen is the actual size of the compressed buffer.
+     This function can be used to decompress a whole file at once if the
+   input file is mmap'ed.
+
+     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.
+*/
+
+
+typedef voidp gzFile;
+
+ZEXTERN gzFile ZEXPORT gzopen  OF((const char *path, const char *mode));
+/*
+     Opens a gzip (.gz) file for reading or writing. The mode parameter
+   is as in fopen ("rb" or "wb") but can also include a compression level
+   ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
+   Huffman only compression as in "wb1h", or 'R' for run-length encoding
+   as in "wb1R". (See the description of deflateInit2 for more information
+   about the strategy parameter.)
+
+     gzopen can be used to read a file which is not in gzip format; in this
+   case gzread will directly read from the file without decompression.
+
+     gzopen returns NULL if the file could not be opened or if there was
+   insufficient memory to allocate the (de)compression state; errno
+   can be checked to distinguish the two cases (if errno is zero, the
+   zlib error is Z_MEM_ERROR).  */
+
+long long gzgetMtime(gzFile file);
+/* Return modify time */
+
+ZEXTERN gzFile ZEXPORT gzdopen  OF((int fd, const char *mode));
+/*
+     gzdopen() associates a gzFile with the file descriptor fd.  File
+   descriptors are obtained from calls like open, dup, creat, pipe or
+   fileno (in the file has been previously opened with fopen).
+   The mode parameter is as in gzopen.
+     The next call of gzclose on the returned gzFile will also close the
+   file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
+   descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
+     gzdopen returns NULL if there was insufficient memory to allocate
+   the (de)compression state.
+*/
+
+ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+/*
+     Dynamically update the compression level or strategy. See the description
+   of deflateInit2 for the meaning of these parameters.
+     gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
+   opened for writing.
+*/
+
+ZEXTERN int ZEXPORT    gzread  OF((gzFile file, voidp buf, unsigned len));
+/*
+     Reads the given number of uncompressed bytes from the compressed file.
+   If the input file was not in gzip format, gzread copies the given number
+   of bytes into the buffer.
+     gzread returns the number of uncompressed bytes actually read (0 for
+   end of file, -1 for error). */
+
+ZEXTERN int ZEXPORT    gzwrite OF((gzFile file,
+                                   voidpc buf, unsigned len));
+/*
+     Writes the given number of uncompressed bytes into the compressed file.
+   gzwrite returns the number of uncompressed bytes actually written
+   (0 in case of error).
+*/
+
+ZEXTERN int ZEXPORTVA   gzprintf OF((gzFile file, const char *format, ...));
+/*
+     Converts, formats, and writes the args to the compressed file under
+   control of the format string, as in fprintf. gzprintf returns the number of
+   uncompressed bytes actually written (0 in case of error).  The number of
+   uncompressed bytes written is limited to 4095. The caller should assure that
+   this limit is not exceeded. If it is exceeded, then gzprintf() will return
+   return an error (0) with nothing written. In this case, there may also be a
+   buffer overflow with unpredictable consequences, which is possible only if
+   zlib was compiled with the insecure functions sprintf() or vsprintf()
+   because the secure snprintf() or vsnprintf() functions were not available.
+*/
+
+ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
+/*
+      Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+      gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+/*
+      Reads bytes from the compressed file until len-1 characters are read, or
+   a newline character is read and transferred to buf, or an end-of-file
+   condition is encountered.  The string is then terminated with a null
+   character.
+      gzgets returns buf, or Z_NULL in case of error.
+*/
+
+ZEXTERN int ZEXPORT    gzputc OF((gzFile file, int c));
+/*
+      Writes c, converted to an unsigned char, into the compressed file.
+   gzputc returns the value that was written, or -1 in case of error.
+*/
+
+ZEXTERN int ZEXPORT    gzgetc OF((gzFile file));
+/*
+      Reads one byte from the compressed file. gzgetc returns this byte
+   or -1 in case of end of file or error.
+*/
+
+ZEXTERN int ZEXPORT    gzungetc OF((int c, gzFile file));
+/*
+      Push one character back onto the stream to be read again later.
+   Only one character of push-back is allowed.  gzungetc() returns the
+   character pushed, or -1 on failure.  gzungetc() will fail if a
+   character has been pushed but not read yet, or if c is -1. The pushed
+   character will be discarded if the stream is repositioned with gzseek()
+   or gzrewind().
+*/
+
+ZEXTERN int ZEXPORT    gzflush OF((gzFile file, int flush));
+/*
+     Flushes all pending output into the compressed file. The parameter
+   flush is as in the deflate() function. The return value is the zlib
+   error number (see function gzerror below). gzflush returns Z_OK if
+   the flush parameter is Z_FINISH and all output could be flushed.
+     gzflush should be called only when strictly necessary because it can
+   degrade compression.
+*/
+
+ZEXTERN z_off_t ZEXPORT    gzseek OF((gzFile file,
+                                      z_off_t offset, int whence));
+/*
+      Sets the starting position for the next gzread or gzwrite on the
+   given compressed file. The offset represents a number of bytes in the
+   uncompressed data stream. The whence parameter is defined as in lseek(2);
+   the value SEEK_END is not supported.
+     If the file is opened for reading, this function is emulated but can be
+   extremely slow. If the file is opened for writing, only forward seeks are
+   supported; gzseek then compresses a sequence of zeroes up to the new
+   starting position.
+
+      gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error, in
+   particular if the file is opened for writing and the new starting position
+   would be before the current position.
+*/
+
+ZEXTERN int ZEXPORT    gzrewind OF((gzFile file));
+/*
+     Rewinds the given file. This function is supported only for reading.
+
+   gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
+*/
+
+ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
+/*
+     Returns the starting position for the next gzread or gzwrite on the
+   given compressed file. This position represents a number of bytes in the
+   uncompressed data stream.
+
+   gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+ZEXTERN int ZEXPORT gzeof OF((gzFile file));
+/*
+     Returns 1 when EOF has previously been detected reading the given
+   input stream, otherwise zero.
+*/
+
+ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
+/*
+     Returns 1 if file is being read directly without decompression, otherwise
+   zero.
+*/
+
+ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
+/*
+     Flushes all pending output if necessary, closes the compressed file
+   and deallocates all the (de)compression state. The return value is the zlib
+   error number (see function gzerror below).
+*/
+
+ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
+/*
+     Returns the error message for the last error which occurred on the
+   given compressed file. errnum is set to zlib error number. If an
+   error occurred in the file system and not in the compression library,
+   errnum is set to Z_ERRNO and the application may consult errno
+   to get the exact error code.
+*/
+
+ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
+/*
+     Clears the error and end-of-file flags for file. This is analogous to the
+   clearerr() function in stdio. This is useful for continuing to read a gzip
+   file that is being written concurrently.
+*/
+
+                        /* checksum functions */
+
+/*
+     These functions are not related to compression but are exported
+   anyway because they might be useful in applications using the
+   compression library.
+*/
+
+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+/*
+     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+   return the updated checksum. If buf is NULL, this function returns
+   the required initial value for the checksum.
+   An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+   much faster. Usage example:
+
+     uLong adler = adler32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       adler = adler32(adler, buffer, length);
+     }
+     if (adler != original_adler) error();
+*/
+
+ZEXTERN void ZEXPORT adler32_range OF((uLong* min, uLong* max));
+/*
+     Set *min and *max (both of which must not be null) to the minimum and
+   maximum possible checksum values that adler32 can produce.
+
+     This function is not part of original software distribution.  It is
+   added at Google (2003) in accordance with the copyright notice above,
+   which permits alteration and redistribution of the original software
+   provided, among other things, that altered source versions must be
+   plainly marked as such and not misrepresented as being the original
+   software.  
+*/
+
+ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
+                                          z_off_t len2));
+/*
+     Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
+   and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
+   each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
+   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.
+*/
+
+ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
+/*
+     Update a running CRC-32 with the bytes buf[0..len-1] and return the
+   updated CRC-32. If buf is NULL, this function returns the required initial
+   value for the for the crc. Pre- and post-conditioning (one's complement) is
+   performed within this function so it shouldn't be done by the application.
+   Usage example:
+
+     uLong crc = crc32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       crc = crc32(crc, buffer, length);
+     }
+     if (crc != original_crc) error();
+*/
+
+ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
+
+/*
+     Combine two CRC-32 check values into one.  For two sequences of bytes,
+   seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
+   calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32
+   check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
+   len2.
+*/
+
+
+                        /* various hacks, don't look :) */
+
+/* deflateInit and inflateInit are macros to allow checking the zlib version
+ * and the compiler's view of z_stream:
+ */
+ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
+                                      int windowBits, int memLevel,
+                                      int strategy, const char *version,
+                                      int stream_size));
+ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
+                                      const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
+                                         unsigned char FAR *window,
+                                         const char *version,
+                                         int stream_size));
+#define deflateInit(strm, level) \
+        deflateInit_((strm), (level),       ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit(strm) \
+        inflateInit_((strm),                ZLIB_VERSION, sizeof(z_stream))
+#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+        deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                      (strategy),           ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit2(strm, windowBits) \
+        inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+#define inflateBackInit(strm, windowBits, window) \
+        inflateBackInit_((strm), (windowBits), (window), \
+        ZLIB_VERSION, sizeof(z_stream))
+
+
+#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
+    struct internal_state {int dummy;}; /* hack for buggy compilers */
+#endif
+
+ZEXTERN const char   * ZEXPORT zError           OF((int));
+ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp z));
+ZEXTERN const uLongf * ZEXPORT get_crc_table    OF((void));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZLIB_H */
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/addrcache_test/addrcache_test.vcproj b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/addrcache_test/addrcache_test.vcproj
new file mode 100644
index 0000000..c962822
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/addrcache_test/addrcache_test.vcproj
@@ -0,0 +1,209 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="addrcache_test"
+	ProjectGUID="{23DDE803-E417-41CE-9D24-B823A990D0FC}"
+	RootNamespace="addrcache_test"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\addrcache_test.cc"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/blockhash_test/blockhash_test.vcproj b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/blockhash_test/blockhash_test.vcproj
new file mode 100644
index 0000000..eeeb6f9
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/blockhash_test/blockhash_test.vcproj
@@ -0,0 +1,209 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="blockhash_test"
+	ProjectGUID="{11C53677-B705-42C2-B50F-87F5E599ABF1}"
+	RootNamespace="blockhash_test"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\blockhash_test.cc"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/codetable_test/codetable_test.vcproj b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/codetable_test/codetable_test.vcproj
new file mode 100644
index 0000000..e83ce9c
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/codetable_test/codetable_test.vcproj
@@ -0,0 +1,209 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="codetable_test"
+	ProjectGUID="{43DD2BA4-493D-49B7-825E-10279C89F0F9}"
+	RootNamespace="codetable_test"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\codetable_test.cc"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/config.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/config.h
new file mode 100644
index 0000000..047ad75
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/config.h
@@ -0,0 +1,74 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// A config.h to be used for MS Visual Studio projects, when the configure
+// script cannot be used to automatically determine the capabilities of
+// the environment.
+
+#ifndef OPEN_VCDIFF_VSPROJECTS_CONFIG_H_
+#define OPEN_VCDIFF_VSPROJECTS_CONFIG_H_
+
+/* Define to 1 if you have the `InitializeCriticalSection' function. */
+#define HAVE_INITIALIZECRITICALSECTION 1
+
+/* Define to 1 if you have the `InterlockedCompareExchange' function. */
+#define HAVE_INTERLOCKEDCOMPAREEXCHANGE 1
+
+/* Define to 1 if you have the `QueryPerformanceCounter' function. */
+#define HAVE_QUERYPERFORMANCECOUNTER 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <windows.h> header file. */
+#define HAVE_WINDOWS_H 1
+
+/* Define to 1 if the system has the type `__int16'. */
+#define HAVE___INT16 1
+
+
+/* Name of package */
+#define PACKAGE "open-vcdiff"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "opensource@google.com"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "open-vcdiff"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "open-vcdiff 0.1"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "open-vcdiff"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "0.1"
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Version number of package */
+#define VERSION "0.1"
+
+// These functions have different names, but the same behavior,
+// for Visual Studio.
+#define strcasecmp _stricmp
+#define snprintf _snprintf
+
+#endif  // OPEN_VCDIFF_VSPROJECTS_CONFIG_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/decodetable_test/decodetable_test.vcproj b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/decodetable_test/decodetable_test.vcproj
new file mode 100644
index 0000000..7342498
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/decodetable_test/decodetable_test.vcproj
@@ -0,0 +1,209 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="decodetable_test"
+	ProjectGUID="{CCA8B377-0D14-4AD3-B5D8-7DD935A2D6D8}"
+	RootNamespace="decodetable_test"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\decodetable_test.cc"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/encodetable_test/encodetable_test.vcproj b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/encodetable_test/encodetable_test.vcproj
new file mode 100644
index 0000000..4eed42e
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/encodetable_test/encodetable_test.vcproj
@@ -0,0 +1,209 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="encodetable_test"
+	ProjectGUID="{893DCA29-2740-4C49-993F-42A9B1EF365B}"
+	RootNamespace="encodetable_test"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\encodetable_test.cc"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/gtest/gtest.vcproj b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/gtest/gtest.vcproj
new file mode 100644
index 0000000..7bb2fe1
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/gtest/gtest.vcproj
@@ -0,0 +1,241 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="gtest"
+	ProjectGUID="{429392EB-55A9-4344-913C-DEE5F02B538D}"
+	RootNamespace="gtest"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
+				RuntimeLibrary="2"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\gtest\gtest-death-test.cc"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\gtest\gtest-filepath.cc"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\gtest\gtest-port.cc"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\gtest\gtest.cc"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\gtest\gtest_main.cc"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath="..\..\src\gtest\internal\gtest-death-test-internal.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\gtest\gtest-death-test.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\gtest\internal\gtest-filepath.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\gtest\src\gtest-internal-inl.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\gtest\internal\gtest-internal.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\gtest\gtest-message.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\gtest\internal\gtest-port.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\gtest\gtest-spi.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\gtest\internal\gtest-string.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\gtest\gtest.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\gtest\gtest_pred_impl.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\gtest\gtest_prod.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/headerparser_test/headerparser_test.vcproj b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/headerparser_test/headerparser_test.vcproj
new file mode 100644
index 0000000..0345b90
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/headerparser_test/headerparser_test.vcproj
@@ -0,0 +1,209 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="headerparser_test"
+	ProjectGUID="{B1995AAE-F24B-4079-8F6B-8333ED6B13A6}"
+	RootNamespace="headerparser_test"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\headerparser_test.cc"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/open-vcdiff.sln b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/open-vcdiff.sln
new file mode 100644
index 0000000..6827e4e
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/open-vcdiff.sln
@@ -0,0 +1,184 @@
+
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual Studio 2005
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vcdcom", "vcdcom\vcdcom.vcproj", "{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vcddec", "vcddec\vcddec.vcproj", "{1066F2E6-3F29-4D3D-9BBA-FD1D360099DD}"
+	ProjectSection(ProjectDependencies) = postProject
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246} = {A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vcdenc", "vcdenc\vcdenc.vcproj", "{C498DA26-B014-44BD-A387-EB6C3CE16FCF}"
+	ProjectSection(ProjectDependencies) = postProject
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246} = {A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vcdiff", "vcdiff\vcdiff.vcproj", "{D11A04C5-0B05-4E08-AAB2-8BC64DE56A84}"
+	ProjectSection(ProjectDependencies) = postProject
+		{C498DA26-B014-44BD-A387-EB6C3CE16FCF} = {C498DA26-B014-44BD-A387-EB6C3CE16FCF}
+		{1066F2E6-3F29-4D3D-9BBA-FD1D360099DD} = {1066F2E6-3F29-4D3D-9BBA-FD1D360099DD}
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246} = {A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "addrcache_test", "addrcache_test\addrcache_test.vcproj", "{23DDE803-E417-41CE-9D24-B823A990D0FC}"
+	ProjectSection(ProjectDependencies) = postProject
+		{429392EB-55A9-4344-913C-DEE5F02B538D} = {429392EB-55A9-4344-913C-DEE5F02B538D}
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246} = {A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "headerparser_test", "headerparser_test\headerparser_test.vcproj", "{B1995AAE-F24B-4079-8F6B-8333ED6B13A6}"
+	ProjectSection(ProjectDependencies) = postProject
+		{429392EB-55A9-4344-913C-DEE5F02B538D} = {429392EB-55A9-4344-913C-DEE5F02B538D}
+		{1066F2E6-3F29-4D3D-9BBA-FD1D360099DD} = {1066F2E6-3F29-4D3D-9BBA-FD1D360099DD}
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246} = {A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vcdecoder_test", "vcdecoder_test\vcdecoder_test.vcproj", "{BA30F970-A2B3-4D04-81D5-B5C73794BEDE}"
+	ProjectSection(ProjectDependencies) = postProject
+		{429392EB-55A9-4344-913C-DEE5F02B538D} = {429392EB-55A9-4344-913C-DEE5F02B538D}
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246} = {A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}
+		{1066F2E6-3F29-4D3D-9BBA-FD1D360099DD} = {1066F2E6-3F29-4D3D-9BBA-FD1D360099DD}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vcencoder_test", "vcencoder_test\vcencoder_test.vcproj", "{CB30C697-D33C-4410-94DE-D7CC481A5284}"
+	ProjectSection(ProjectDependencies) = postProject
+		{429392EB-55A9-4344-913C-DEE5F02B538D} = {429392EB-55A9-4344-913C-DEE5F02B538D}
+		{1066F2E6-3F29-4D3D-9BBA-FD1D360099DD} = {1066F2E6-3F29-4D3D-9BBA-FD1D360099DD}
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246} = {A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}
+		{C498DA26-B014-44BD-A387-EB6C3CE16FCF} = {C498DA26-B014-44BD-A387-EB6C3CE16FCF}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "output_string_test", "output_string_test\output_string_test.vcproj", "{3E9B97B7-7C57-44EB-BBBC-2C3B56595F0E}"
+	ProjectSection(ProjectDependencies) = postProject
+		{429392EB-55A9-4344-913C-DEE5F02B538D} = {429392EB-55A9-4344-913C-DEE5F02B538D}
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246} = {A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "blockhash_test", "blockhash_test\blockhash_test.vcproj", "{11C53677-B705-42C2-B50F-87F5E599ABF1}"
+	ProjectSection(ProjectDependencies) = postProject
+		{429392EB-55A9-4344-913C-DEE5F02B538D} = {429392EB-55A9-4344-913C-DEE5F02B538D}
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246} = {A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}
+		{C498DA26-B014-44BD-A387-EB6C3CE16FCF} = {C498DA26-B014-44BD-A387-EB6C3CE16FCF}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "codetable_test", "codetable_test\codetable_test.vcproj", "{43DD2BA4-493D-49B7-825E-10279C89F0F9}"
+	ProjectSection(ProjectDependencies) = postProject
+		{429392EB-55A9-4344-913C-DEE5F02B538D} = {429392EB-55A9-4344-913C-DEE5F02B538D}
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246} = {A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "decodetable_test", "decodetable_test\decodetable_test.vcproj", "{CCA8B377-0D14-4AD3-B5D8-7DD935A2D6D8}"
+	ProjectSection(ProjectDependencies) = postProject
+		{429392EB-55A9-4344-913C-DEE5F02B538D} = {429392EB-55A9-4344-913C-DEE5F02B538D}
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246} = {A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}
+		{1066F2E6-3F29-4D3D-9BBA-FD1D360099DD} = {1066F2E6-3F29-4D3D-9BBA-FD1D360099DD}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "encodetable_test", "encodetable_test\encodetable_test.vcproj", "{893DCA29-2740-4C49-993F-42A9B1EF365B}"
+	ProjectSection(ProjectDependencies) = postProject
+		{429392EB-55A9-4344-913C-DEE5F02B538D} = {429392EB-55A9-4344-913C-DEE5F02B538D}
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246} = {A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}
+		{C498DA26-B014-44BD-A387-EB6C3CE16FCF} = {C498DA26-B014-44BD-A387-EB6C3CE16FCF}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "rolling_hash_test", "rolling_hash_test\rolling_hash_test.vcproj", "{A9879052-0DD1-413D-B631-A82044BFCF1A}"
+	ProjectSection(ProjectDependencies) = postProject
+		{429392EB-55A9-4344-913C-DEE5F02B538D} = {429392EB-55A9-4344-913C-DEE5F02B538D}
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246} = {A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}
+		{C498DA26-B014-44BD-A387-EB6C3CE16FCF} = {C498DA26-B014-44BD-A387-EB6C3CE16FCF}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "varint_bigendian_test", "varint_bigendian_test\varint_bigendian_test.vcproj", "{9A887AB5-E053-4ED6-870B-3330A1F4ED83}"
+	ProjectSection(ProjectDependencies) = postProject
+		{429392EB-55A9-4344-913C-DEE5F02B538D} = {429392EB-55A9-4344-913C-DEE5F02B538D}
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246} = {A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vcdiffengine_test", "vcdiffengine_test\vcdiffengine_test.vcproj", "{890398AC-020D-48C7-A054-6E03B1403AC7}"
+	ProjectSection(ProjectDependencies) = postProject
+		{429392EB-55A9-4344-913C-DEE5F02B538D} = {429392EB-55A9-4344-913C-DEE5F02B538D}
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246} = {A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}
+		{C498DA26-B014-44BD-A387-EB6C3CE16FCF} = {C498DA26-B014-44BD-A387-EB6C3CE16FCF}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest", "gtest\gtest.vcproj", "{429392EB-55A9-4344-913C-DEE5F02B538D}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}.Debug|Win32.ActiveCfg = Debug|Win32
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}.Debug|Win32.Build.0 = Debug|Win32
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}.Release|Win32.ActiveCfg = Release|Win32
+		{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}.Release|Win32.Build.0 = Release|Win32
+		{1066F2E6-3F29-4D3D-9BBA-FD1D360099DD}.Debug|Win32.ActiveCfg = Debug|Win32
+		{1066F2E6-3F29-4D3D-9BBA-FD1D360099DD}.Debug|Win32.Build.0 = Debug|Win32
+		{1066F2E6-3F29-4D3D-9BBA-FD1D360099DD}.Release|Win32.ActiveCfg = Release|Win32
+		{1066F2E6-3F29-4D3D-9BBA-FD1D360099DD}.Release|Win32.Build.0 = Release|Win32
+		{C498DA26-B014-44BD-A387-EB6C3CE16FCF}.Debug|Win32.ActiveCfg = Debug|Win32
+		{C498DA26-B014-44BD-A387-EB6C3CE16FCF}.Debug|Win32.Build.0 = Debug|Win32
+		{C498DA26-B014-44BD-A387-EB6C3CE16FCF}.Release|Win32.ActiveCfg = Release|Win32
+		{C498DA26-B014-44BD-A387-EB6C3CE16FCF}.Release|Win32.Build.0 = Release|Win32
+		{D11A04C5-0B05-4E08-AAB2-8BC64DE56A84}.Debug|Win32.ActiveCfg = Debug|Win32
+		{D11A04C5-0B05-4E08-AAB2-8BC64DE56A84}.Debug|Win32.Build.0 = Debug|Win32
+		{D11A04C5-0B05-4E08-AAB2-8BC64DE56A84}.Release|Win32.ActiveCfg = Release|Win32
+		{D11A04C5-0B05-4E08-AAB2-8BC64DE56A84}.Release|Win32.Build.0 = Release|Win32
+		{23DDE803-E417-41CE-9D24-B823A990D0FC}.Debug|Win32.ActiveCfg = Debug|Win32
+		{23DDE803-E417-41CE-9D24-B823A990D0FC}.Debug|Win32.Build.0 = Debug|Win32
+		{23DDE803-E417-41CE-9D24-B823A990D0FC}.Release|Win32.ActiveCfg = Release|Win32
+		{23DDE803-E417-41CE-9D24-B823A990D0FC}.Release|Win32.Build.0 = Release|Win32
+		{B1995AAE-F24B-4079-8F6B-8333ED6B13A6}.Debug|Win32.ActiveCfg = Debug|Win32
+		{B1995AAE-F24B-4079-8F6B-8333ED6B13A6}.Debug|Win32.Build.0 = Debug|Win32
+		{B1995AAE-F24B-4079-8F6B-8333ED6B13A6}.Release|Win32.ActiveCfg = Release|Win32
+		{B1995AAE-F24B-4079-8F6B-8333ED6B13A6}.Release|Win32.Build.0 = Release|Win32
+		{BA30F970-A2B3-4D04-81D5-B5C73794BEDE}.Debug|Win32.ActiveCfg = Debug|Win32
+		{BA30F970-A2B3-4D04-81D5-B5C73794BEDE}.Debug|Win32.Build.0 = Debug|Win32
+		{BA30F970-A2B3-4D04-81D5-B5C73794BEDE}.Release|Win32.ActiveCfg = Release|Win32
+		{BA30F970-A2B3-4D04-81D5-B5C73794BEDE}.Release|Win32.Build.0 = Release|Win32
+		{CB30C697-D33C-4410-94DE-D7CC481A5284}.Debug|Win32.ActiveCfg = Debug|Win32
+		{CB30C697-D33C-4410-94DE-D7CC481A5284}.Debug|Win32.Build.0 = Debug|Win32
+		{CB30C697-D33C-4410-94DE-D7CC481A5284}.Release|Win32.ActiveCfg = Release|Win32
+		{CB30C697-D33C-4410-94DE-D7CC481A5284}.Release|Win32.Build.0 = Release|Win32
+		{3E9B97B7-7C57-44EB-BBBC-2C3B56595F0E}.Debug|Win32.ActiveCfg = Debug|Win32
+		{3E9B97B7-7C57-44EB-BBBC-2C3B56595F0E}.Debug|Win32.Build.0 = Debug|Win32
+		{3E9B97B7-7C57-44EB-BBBC-2C3B56595F0E}.Release|Win32.ActiveCfg = Release|Win32
+		{3E9B97B7-7C57-44EB-BBBC-2C3B56595F0E}.Release|Win32.Build.0 = Release|Win32
+		{11C53677-B705-42C2-B50F-87F5E599ABF1}.Debug|Win32.ActiveCfg = Debug|Win32
+		{11C53677-B705-42C2-B50F-87F5E599ABF1}.Debug|Win32.Build.0 = Debug|Win32
+		{11C53677-B705-42C2-B50F-87F5E599ABF1}.Release|Win32.ActiveCfg = Release|Win32
+		{11C53677-B705-42C2-B50F-87F5E599ABF1}.Release|Win32.Build.0 = Release|Win32
+		{43DD2BA4-493D-49B7-825E-10279C89F0F9}.Debug|Win32.ActiveCfg = Debug|Win32
+		{43DD2BA4-493D-49B7-825E-10279C89F0F9}.Debug|Win32.Build.0 = Debug|Win32
+		{43DD2BA4-493D-49B7-825E-10279C89F0F9}.Release|Win32.ActiveCfg = Release|Win32
+		{43DD2BA4-493D-49B7-825E-10279C89F0F9}.Release|Win32.Build.0 = Release|Win32
+		{CCA8B377-0D14-4AD3-B5D8-7DD935A2D6D8}.Debug|Win32.ActiveCfg = Debug|Win32
+		{CCA8B377-0D14-4AD3-B5D8-7DD935A2D6D8}.Debug|Win32.Build.0 = Debug|Win32
+		{CCA8B377-0D14-4AD3-B5D8-7DD935A2D6D8}.Release|Win32.ActiveCfg = Release|Win32
+		{CCA8B377-0D14-4AD3-B5D8-7DD935A2D6D8}.Release|Win32.Build.0 = Release|Win32
+		{893DCA29-2740-4C49-993F-42A9B1EF365B}.Debug|Win32.ActiveCfg = Debug|Win32
+		{893DCA29-2740-4C49-993F-42A9B1EF365B}.Debug|Win32.Build.0 = Debug|Win32
+		{893DCA29-2740-4C49-993F-42A9B1EF365B}.Release|Win32.ActiveCfg = Release|Win32
+		{893DCA29-2740-4C49-993F-42A9B1EF365B}.Release|Win32.Build.0 = Release|Win32
+		{A9879052-0DD1-413D-B631-A82044BFCF1A}.Debug|Win32.ActiveCfg = Debug|Win32
+		{A9879052-0DD1-413D-B631-A82044BFCF1A}.Debug|Win32.Build.0 = Debug|Win32
+		{A9879052-0DD1-413D-B631-A82044BFCF1A}.Release|Win32.ActiveCfg = Release|Win32
+		{A9879052-0DD1-413D-B631-A82044BFCF1A}.Release|Win32.Build.0 = Release|Win32
+		{9A887AB5-E053-4ED6-870B-3330A1F4ED83}.Debug|Win32.ActiveCfg = Debug|Win32
+		{9A887AB5-E053-4ED6-870B-3330A1F4ED83}.Debug|Win32.Build.0 = Debug|Win32
+		{9A887AB5-E053-4ED6-870B-3330A1F4ED83}.Release|Win32.ActiveCfg = Release|Win32
+		{9A887AB5-E053-4ED6-870B-3330A1F4ED83}.Release|Win32.Build.0 = Release|Win32
+		{890398AC-020D-48C7-A054-6E03B1403AC7}.Debug|Win32.ActiveCfg = Debug|Win32
+		{890398AC-020D-48C7-A054-6E03B1403AC7}.Debug|Win32.Build.0 = Debug|Win32
+		{890398AC-020D-48C7-A054-6E03B1403AC7}.Release|Win32.ActiveCfg = Release|Win32
+		{890398AC-020D-48C7-A054-6E03B1403AC7}.Release|Win32.Build.0 = Release|Win32
+		{429392EB-55A9-4344-913C-DEE5F02B538D}.Debug|Win32.ActiveCfg = Debug|Win32
+		{429392EB-55A9-4344-913C-DEE5F02B538D}.Debug|Win32.Build.0 = Debug|Win32
+		{429392EB-55A9-4344-913C-DEE5F02B538D}.Release|Win32.ActiveCfg = Release|Win32
+		{429392EB-55A9-4344-913C-DEE5F02B538D}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/output_string_test/output_string_test.vcproj b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/output_string_test/output_string_test.vcproj
new file mode 100644
index 0000000..98cfd7e
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/output_string_test/output_string_test.vcproj
@@ -0,0 +1,213 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="output_string_test"
+	ProjectGUID="{3E9B97B7-7C57-44EB-BBBC-2C3B56595F0E}"
+	RootNamespace="output_string_test"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\output_string_test.cc"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath="..\..\src\output_string_crope.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/rolling_hash_test/rolling_hash_test.vcproj b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/rolling_hash_test/rolling_hash_test.vcproj
new file mode 100644
index 0000000..74a1061
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/rolling_hash_test/rolling_hash_test.vcproj
@@ -0,0 +1,209 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="rolling_hash_test"
+	ProjectGUID="{A9879052-0DD1-413D-B631-A82044BFCF1A}"
+	RootNamespace="rolling_hash_test"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\rolling_hash_test.cc"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/stdint.h b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/stdint.h
new file mode 100644
index 0000000..d1db4a4
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/stdint.h
@@ -0,0 +1,30 @@
+// Copyright 2008 Google Inc.
+// Author: Lincoln Smith
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Replacement for the standard <stdint.h>, to be used only when the
+// package is compiled using MS Visual Studio.
+
+#ifndef OPEN_VCDIFF_STDINT_H_
+#define OPEN_VCDIFF_STDINT_H_
+
+typedef __int16 int16_t;
+typedef __int32 int32_t;
+typedef __int64 int64_t;
+
+typedef unsigned __int16 uint16_t;
+typedef unsigned __int32 uint32_t;
+typedef unsigned __int64 uint64_t;
+
+#endif  // OPEN_VCDIFF_STDINT_H_
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/varint_bigendian_test/varint_bigendian_test.vcproj b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/varint_bigendian_test/varint_bigendian_test.vcproj
new file mode 100644
index 0000000..c0826a8
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/varint_bigendian_test/varint_bigendian_test.vcproj
@@ -0,0 +1,209 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="varint_bigendian_test"
+	ProjectGUID="{9A887AB5-E053-4ED6-870B-3330A1F4ED83}"
+	RootNamespace="varint_bigendian_test"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\varint_bigendian_test.cc"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcdcom/vcdcom.vcproj b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcdcom/vcdcom.vcproj
new file mode 100644
index 0000000..4dbde26
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcdcom/vcdcom.vcproj
@@ -0,0 +1,227 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="vcdcom"
+	ProjectGUID="{A49D16EE-E69E-4B5D-9CB7-ABEF79BB4246}"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="Debug"
+			ConfigurationType="4"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="Release"
+			ConfigurationType="4"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				RuntimeLibrary="2"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath="..\..\src\addrcache.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\codetable.h"
+				>
+			</File>
+			<File
+				RelativePath="..\config.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\logging.h"
+				>
+			</File>
+			<File
+				RelativePath=".\stdint.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\testing.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\varint_bigendian.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\vcdiff_defs.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\zconf.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\zlib.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\addrcache.cc"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\adler32.c"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\codetable.cc"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\logging.cc"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\varint_bigendian.cc"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcddec/vcddec.vcproj b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcddec/vcddec.vcproj
new file mode 100644
index 0000000..22b93f5
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcddec/vcddec.vcproj
@@ -0,0 +1,200 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="vcddec"
+	ProjectGUID="{1066F2E6-3F29-4D3D-9BBA-FD1D360099DD}"
+	RootNamespace="vcddec"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="Debug"
+			ConfigurationType="4"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="Release"
+			ConfigurationType="4"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				RuntimeLibrary="2"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath="..\..\src\checksum.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\decodetable.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\headerparser.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\google\output_string.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\google\vcdecoder.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\decodetable.cc"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\headerparser.cc"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\vcdecoder.cc"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcdecoder_test/vcdecoder_test.vcproj b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcdecoder_test/vcdecoder_test.vcproj
new file mode 100644
index 0000000..42e8ab1
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcdecoder_test/vcdecoder_test.vcproj
@@ -0,0 +1,209 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="vcdecoder_test"
+	ProjectGUID="{BA30F970-A2B3-4D04-81D5-B5C73794BEDE}"
+	RootNamespace="vcdecoder_test"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\vcdecoder_test.cc"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcdenc/vcdenc.vcproj b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcdenc/vcdenc.vcproj
new file mode 100644
index 0000000..9724d99
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcdenc/vcdenc.vcproj
@@ -0,0 +1,215 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="vcdenc"
+	ProjectGUID="{C498DA26-B014-44BD-A387-EB6C3CE16FCF}"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="Debug"
+			ConfigurationType="4"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="Release"
+			ConfigurationType="4"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				RuntimeLibrary="2"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath="..\..\src\blockhash.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\checksum.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\compile_assert.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\encodetable.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\google\output_string.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\rolling_hash.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\vcdiffengine.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\google\vcencoder.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\blockhash.cc"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\encodetable.cc"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\vcdiffengine.cc"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\vcencoder.cc"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcdiff/vcdiff.vcproj b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcdiff/vcdiff.vcproj
new file mode 100644
index 0000000..9eec19f
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcdiff/vcdiff.vcproj
@@ -0,0 +1,259 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="vcdiff"
+	ProjectGUID="{D11A04C5-0B05-4E08-AAB2-8BC64DE56A84}"
+	RootNamespace="vcdiff"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="$(OutDir)\vcddec.lib $(OutDir)\vcdenc.lib $(OutDir)\vcdcom.lib"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="$(OutDir)\vcddec.lib $(OutDir)\vcdenc.lib $(OutDir)\vcdcom.lib"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\gflags.cc"
+				>
+				<FileConfiguration
+					Name="Debug|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						DisableSpecificWarnings="4996"
+					/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						DisableSpecificWarnings="4996"
+					/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\..\src\gflags_reporting.cc"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\vcdiff_main.cc"
+				>
+				<FileConfiguration
+					Name="Debug|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						DisableSpecificWarnings="4996"
+					/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						DisableSpecificWarnings="4996"
+					/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath="..\config.h"
+				>
+			</File>
+			<File
+				RelativePath="..\google\gflags.h"
+				>
+			</File>
+			<File
+				RelativePath="..\google\gflags_completions.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcdiffengine_test/vcdiffengine_test.vcproj b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcdiffengine_test/vcdiffengine_test.vcproj
new file mode 100644
index 0000000..f90e887
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcdiffengine_test/vcdiffengine_test.vcproj
@@ -0,0 +1,209 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="vcdiffengine_test"
+	ProjectGUID="{890398AC-020D-48C7-A054-6E03B1403AC7}"
+	RootNamespace="vcdiffengine_test"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\vcdiffengine_test.cc"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcencoder_test/vcencoder_test.vcproj b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcencoder_test/vcencoder_test.vcproj
new file mode 100644
index 0000000..d7814c3
--- /dev/null
+++ b/sdch/open_vcdiff/depot/opensource/open-vcdiff/vsprojects/vcencoder_test/vcencoder_test.vcproj
@@ -0,0 +1,211 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="vcencoder_test"
+	ProjectGUID="{CB30C697-D33C-4410-94DE-D7CC481A5284}"
+	RootNamespace="vcencoder_test"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				WarnAsError="true"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			BuildLogFile="$(IntDir)\BuildLog_$(ProjectName).htm"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../..;../../src;../../vsprojects"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				DefaultCharIsUnsigned="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="$(IntDir)\$(ProjectName).pdb"
+				WarningLevel="3"
+				WarnAsError="true"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories=""
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="$(OutDir)\$(ProjectName).exe"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\vcencoder_test.cc"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/sdch.vcproj b/sdch/sdch.vcproj
new file mode 100644
index 0000000..0b37725
--- /dev/null
+++ b/sdch/sdch.vcproj
@@ -0,0 +1,262 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="sdch"
+	ProjectGUID="{F54ABC59-5C00-414A-A9BA-BAF26D1699F0}"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			ConfigurationType="4"
+			InheritedPropertySheets="$(SolutionDir)..\build\debug.vsprops;$(SolutionDir)..\sdch\using_sdch.vsprops"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="./open_vcdiff/depot/opensource/open-vcdiff/vsprojects;"
+				DefaultCharIsUnsigned="true"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			ConfigurationType="4"
+			InheritedPropertySheets="$(SolutionDir)..\build\release.vsprops;$(SolutionDir)..\sdch\using_sdch.vsprops"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="./open_vcdiff/depot/opensource/open-vcdiff/vsprojects;"
+				DefaultCharIsUnsigned="true"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{5612E1F3-EC29-4848-8301-B23786CED3CA}"
+			>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\blockhash.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\checksum.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\codetable.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\compile_assert.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\vsprojects\config.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\decodetable.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\encodetable.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\headerparser.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\logging.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\google\output_string.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\rolling_hash.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\vsprojects\stdint.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\testing.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\varint_bigendian.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\google\vcdecoder.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\vcdiff_defs.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\vcdiffengine.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\zconf.h"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\zlib.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{883D491D-EF73-4c2f-BB09-6F87DC95DC28}"
+			>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\addrcache.cc"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\adler32.c"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\blockhash.cc"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\codetable.cc"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\decodetable.cc"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\encodetable.cc"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\headerparser.cc"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\logging.cc"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\varint_bigendian.cc"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\vcdecoder.cc"
+				>
+			</File>
+			<File
+				RelativePath=".\open_vcdiff\depot\opensource\open-vcdiff\src\vcdiffengine.cc"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/sdch/using_sdch.vsprops b/sdch/using_sdch.vsprops
new file mode 100644
index 0000000..3c25048
--- /dev/null
+++ b/sdch/using_sdch.vsprops
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioPropertySheet
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="using_sdch"
+	>
+	<Tool
+		Name="VCCLCompilerTool"
+		AdditionalIncludeDirectories="$(SolutionDir)..\sdch\open_vcdiff\depot\opensource\open-vcdiff\src;"
+	/>
+</VisualStudioPropertySheet>