Actually store the unpacked files instead of dynamically unpacking

.gitignore

@@ -29,3 +29,10 @@ pip-log.txt
 
 # Generated cffi files
 nacl/_cffi_*.c
+
+# Generate libsodium files
+src/libsodium/**/Makefile
+src/libsodium/config.log
+src/libsodium/config.status
+src/libsodium/libsodium.pc
+src/libsodium/libtool

MANIFEST.in

-include *.gz
 include tox.ini
 include LICENSE
+
+# libsodium files
+include src/libsodium/AUTHORS
+include src/libsodium/ChangeLog
+include src/libsodium/LICENSE
+include src/libsodium/README
+include src/libsodium/THANKS
+include src/libsodium/compile
+include src/libsodium/configure
+include src/libsodium/depcomp
+include src/libsodium/install-sh
+include src/libsodium/missing
+include src/libsodium/test-driver
+recursive-include src *.S
+recursive-include src *.ac
+recursive-include src *.am
+recursive-include src *.c
+recursive-include src *.exp
+recursive-include src *.guess
+recursive-include src *.h
+recursive-include src *.in
+recursive-include src *.m4
+recursive-include src *.markdown
+recursive-include src *.sh
+recursive-include src *.sub
+
+# test files
 recursive-include docs *.png
 recursive-include docs *.py
 recursive-include docs *.rst
 recursive-include docs Makefile
 recursive-include tests *.py
 recursive-include tests/data *
+
+# Remove CFFI files
+recursive-exclude nacl _cffi_*.c

setup.py

 #!/usr/bin/env python
+import functools
 import glob
 import os
 import os.path
 import shlex
-import shutil
 import subprocess
 import sys
-import tarfile
-import tempfile
 
 from distutils.command.build_clib import build_clib as _build_clib
 
@@ -22,6 +20,8 @@ SODIUM_VERSION = "0.4.3"
 def here(*paths):
     return os.path.abspath(os.path.join(os.path.dirname(__file__), *paths))
 
+sodium = functools.partial(here, "src/libsodium/src/libsodium")
+
 
 def which(name, flags=os.X_OK):  # Taken from twisted
     result = []
@@ -52,40 +52,21 @@ except ImportError:
 else:
     # building bdist - cffi is here!
     ext_modules = [nacl.nacl.ffi.verifier.get_extension()]
-    ext_modules[0].include_dirs.append(here("build/sodium/src/libsodium/include"))
+    ext_modules[0].include_dirs.append(sodium("include"))
 
 
 class build_clib(_build_clib):
 
     def run(self):
-        # Unpack the Libsodium Tarball
-        sourcefile = tarfile.open(
-            here("libsodium-%s.tar.gz" % SODIUM_VERSION),
-        )
-
-        tmpdir = tempfile.mkdtemp()
-        try:
-            sourcefile.extractall(tmpdir)
-
-            # Copy our installed directory into the build location
-            shutil.rmtree(here("build/sodium"), ignore_errors=True)
-            shutil.copytree(
-                os.path.join(tmpdir, "libsodium-%s" % SODIUM_VERSION),
-                here("build/sodium")
-            )
-        finally:
-            shutil.rmtree(tmpdir, ignore_errors=True)
-            sourcefile.close()
-
         # Run ./configure
         subprocess.check_call(
             "./configure --disable-debug --disable-dependency-tracking",
-            cwd=here("build/sodium"),
+            cwd=here("src/libsodium"),
             shell=True,
         )
 
         # Parse the Makefile to determine what macros to define
-        with open(here("build/sodium/Makefile")) as makefile:
+        with open(here("src/libsodium/Makefile")) as makefile:
             for line in makefile:
                 if line.startswith("DEFS"):
                     defines = [
@@ -109,36 +90,31 @@ class build_clib(_build_clib):
                 #   TIMODE or not
                 if "HAVE_TI_MODE" in macros:
                     sources.extend([
-                        "crypto_scalarmult/curve25519/donna_c64/base_curve25519_donna_c64.c",
-                        "crypto_scalarmult/curve25519/donna_c64/smult_curve25519_donna_c64.c",
+                        sodium("crypto_scalarmult/curve25519/donna_c64/base_curve25519_donna_c64.c"),
+                        sodium("crypto_scalarmult/curve25519/donna_c64/smult_curve25519_donna_c64.c"),
                     ])
                 else:
                     sources.extend([
-                        "crypto_scalarmult/curve25519/ref/base_curve25519_ref.c",
-                        "crypto_scalarmult/curve25519/ref/smult_curve25519_ref.c",
+                        sodium("crypto_scalarmult/curve25519/ref/base_curve25519_ref.c"),
+                        sodium("crypto_scalarmult/curve25519/ref/smult_curve25519_ref.c"),
                     ])
 
                 # Dynamically modify the implementation based on if we have
                 #   AMD64 ASM or not.
                 if "HAVE_AMD64_ASM" in macros:
                     sources.extend([
-                        "crypto_stream/salsa20/amd64_xmm6/stream_salsa20_amd64_xmm6.S",
+                        sodium("crypto_stream/salsa20/amd64_xmm6/stream_salsa20_amd64_xmm6.S"),
                     ])
 
                     self._include_asm = True
                 else:
                     sources.extend([
-                        "crypto_stream/salsa20/ref/stream_salsa20_ref.c",
-                        "crypto_stream/salsa20/ref/xor_salsa20_ref.c",
+                        sodium("crypto_stream/salsa20/ref/stream_salsa20_ref.c"),
+                        sodium("crypto_stream/salsa20/ref/xor_salsa20_ref.c"),
                     ])
 
                     self._include_asm = False
 
-                # Expand out all of the sources to their full path
-                sources = [
-                    here("build/sodium/src/libsodium", s) for s in sources
-                ]
-
                 build_info["sources"] = sources
 
             libraries.append((libname, build_info))
@@ -207,9 +183,9 @@ setup(
     libraries=[
         ("sodium", {
             "include_dirs": [
-                here("build/sodium/src/libsodium/include/sodium"),
+                sodium("include/sodium"),
             ],
-            "sources": [
+            "sources": map(sodium, [
                 "crypto_auth/crypto_auth.c",
                 "crypto_auth/hmacsha256/auth_hmacsha256_api.c",
                 "crypto_auth/hmacsha256/ref/hmac_hmacsha256.c",
@@ -336,7 +312,7 @@ setup(
                 "sodium/core.c",
                 "sodium/utils.c",
                 "sodium/version.c",
-            ],
+            ]),
         }),
     ],
 

src/libsodium/AUTHORS

+Designers
+=========
+
+crypto_sign/ed25519
+-------------------
+Daniel J. Bernstein
+Niels Duif
+Tanja Lange
+Peter Schwabe
+Bo-Yin Yang
+
+Implementors
+============
+
+crypto_core/hsalsa20
+--------------------
+Daniel J. Bernstein
+
+crypto_core/salsa20
+--------------------
+Daniel J. Bernstein
+
+crypto_core/salsa2012
+-------------------
+Daniel J. Bernstein
+
+crypto_core/salsa208
+---------------------
+Daniel J. Bernstein
+
+crypto_hash/sha256
+------------------
+Daniel J. Bernstein (wrapper around crypto_hashblocks/sha256)
+
+crypto_hash/sha512
+------------------
+Daniel J. Bernstein (wrapper around crypto_hashblocks/sha512)
+
+crypto_hashblocks/sha256
+------------------------
+Daniel J. Bernstein
+
+crypto_hashblocks/sha512
+------------------------
+Daniel J. Bernstein
+
+crypto_scalarmult/curve25519/ref
+--------------------------------
+Matthew Dempsky (Mochi Media)
+
+crypto_scalarmult/curve25519/donna_c64
+--------------------------------------
+Adam Langley (Google)
+
+crypto_sign/ed25519
+-------------------
+Daniel J. Bernstein
+Niels Duif
+Tanja Lange
+lead: Peter Schwabe
+Bo-Yin Yang
+
+crypto_stream/aes128ctr
+-----------------------
+Daniel J. Bernstein
+
+crypto_stream/aes256estream
+---------------------------
+Hongjun Wu
+
+crypto_stream/salsa20
+---------------------
+Daniel J. Bernstein
+
+crypto_stream/salsa2012
+-----------------------
+Daniel J. Bernstein
+
+crypto_stream/salsa208
+----------------------
+Daniel J. Bernstein
+
+crypto_stream/xsalsa20
+----------------------
+Daniel J. Bernstein
+
+crypto_shorthash/siphash24
+--------------------------
+Jean-Philippe Aumasson
+Daniel J. Bernstein
+
+crypto_generichash/blake2b
+--------------------------
+Jean-Philippe Aumasson
+Samuel Neves
+Zooko Wilcox-O'Hearn
+Christian Winnerlein
+
+crypto_onetimeauth/poly1305/donna
+---------------------------------
+Andrew "floodyberry" M.

src/libsodium/ChangeLog

+
+* Version 0.4.3
+ - crypto_sign_seedbytes() and crypto_sign_SEEDBYTES were added.
+ - crypto_onetimeauth_poly1305_implementation_name() was added.
+ - poly1305-ref has been replaced by a faster implementation,
+Floodyberry's poly1305-donna-unrolled.
+ - Stackmarkings have been added to assembly code, for Hardened Gentoo.
+ - pkg-config can now be used in order to retrieve compilations flags for
+using libsodium.
+ - crypto_stream_aes256estream_*() can now deal with unaligned input
+on platforms that require word alignment.
+ - portability improvements.
+
+* Version 0.4.2
+ - All NaCl constants are now also exposed as functions.
+ - The Android and iOS cross-compilation script have been improved.
+ - libsodium can now be cross-compiled to Windows from Linux.
+ - libsodium can now be compiled with emscripten.
+ - New convenience function (prototyped in utils.h): sodium_bin2hex().
+
+* Version 0.4.1
+ - sodium_version_*() functions were not exported in version 0.4. They
+are now visible as intended.
+ - sodium_init() now calls randombytes_stir().
+ - optimized assembly version of salsa20 is now used on amd64.
+ - further cleanups and enhanced compatibility with non-C99 compilers.
+
+* Version 0.4
+ - Most constants and operations are now available as actual functions
+instead of macros, making it easier to use from other languages.
+ - New operation: crypto_generichash, featuring a variable key size, a
+variable output size, and a streaming API. Currently implemented using
+Blake2b.
+ - The package can be compiled in a separate directory.
+ - aes128ctr functions are exported.
+ - Optimized versions of curve25519 (curve25519_donna_c64), poly1305
+(poly1305_53) and ed25519 (ed25519_ref10) are available. Optionally calling
+sodium_init() once before using the library makes it pick the fastest
+implementation.
+ - New convenience function: sodium_memzero() in order to securely
+wipe a memory area.
+ - A whole bunch of cleanups and portability enhancements.
+ - On Windows, a .REF file is generated along with the shared library,
+for use with Visual Studio. The installation path for these has become
+$prefix/bin as expected by MingW.
+
+* Version 0.3
+ - The crypto_shorthash operation has been added, implemented using
+SipHash-2-4.
+
+* Version 0.2
+ - crypto_sign_seed_keypair() has been added
+
+* Version 0.1
+ - Initial release.
+

src/libsodium/LICENSE

+/*
+ * Copyright (c) 2013
+ * Frank Denis <j at pureftpd dot org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */

src/libsodium/Makefile.am

+ACLOCAL_AMFLAGS = -I m4
+
+EXTRA_DIST = \
+	autogen.sh \
+	LICENSE \
+	README.markdown \
+	THANKS
+
+SUBDIRS = \
+	src \
+	test
+
+if HAVE_PKG_CONFIG
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = @PACKAGE_NAME@.pc
+endif

src/libsodium/README

+See README.markdown

src/libsodium/README.markdown

+[![Build Status](https://travis-ci.org/jedisct1/libsodium.png?branch=master)](https://travis-ci.org/jedisct1/libsodium?branch=master)
+
+![libsodium](https://raw.github.com/jedisct1/libsodium/master/logo.png)
+============
+
+[NaCl](http://nacl.cr.yp.to/) (pronounced "salt") is a new easy-to-use
+high-speed software library for network communication, encryption,
+decryption, signatures, etc.
+
+NaCl's goal is to provide all of the core operations needed to build
+higher-level cryptographic tools.
+
+Sodium is a portable, cross-compilable, installable, packageable
+fork of NaCl, with a compatible API.
+
+## Portability
+
+In order to pick the fastest working implementation of each primitive,
+NaCl performs tests and benchmarks at compile-time. Unfortunately, the
+resulting library is not guaranteed to work on different hardware.
+
+Sodium performs tests at run-time, so that the same binary package can
+still run everywhere.
+
+Sodium is tested on a variety of compilers and operating systems,
+including Windows, iOS and Android.
+
+## Installation
+
+Sodium is a shared library with a machine-independent set of
+headers, so that it can easily be used by 3rd party projects.
+
+The library is built using autotools, making it easy to package.
+
+Installation is trivial, and both compilation and testing can take
+advantage of multiple CPU cores.
+
+Download a
+[tarball of libsodium](https://download.libsodium.org/libsodium/releases/),
+then follow the ritual:
+
+    ./configure
+    make && make check && make install
+
+Pre-compiled Win32 packages are available for download at the same
+location.
+
+Integrity of source tarballs can currently be checked using PGP or
+verified DNS queries (`dig +dnssec +short txt <file>.download.libsodium.org`
+returns the SHA256 of any file available for download).
+
+## Comparison with vanilla NaCl
+
+Sodium does not ship C++ bindings. These might be part of a distinct
+package.
+
+The default public-key signature system in NaCl was a prototype that
+shouldn't be used any more.
+
+Sodium ships with the SUPERCOP reference implementation of
+[Ed25519](http://ed25519.cr.yp.to/), and uses this system by default
+for `crypto_sign*` operations.
+
+For backward compatibility, the previous system is still compiled in,
+as `crypto_sign_edwards25519sha512batch*`.
+
+## Additional features
+
+The Sodium library provides some convenience functions in order to retrieve
+the current version of the package and of the shared library:
+
+    const char *sodium_version_string(void);
+    const int   sodium_library_version_major(void);
+    const int   sodium_library_version_minor(void);
+
+Headers are installed in `${prefix}/include/sodium`.
+
+A convenience header includes everything you need to use the library:
+
+    #include <sodium.h>
+
+This is not required, however, before any other libsodium function, you can
+call:
+
+    sodium_init();
+
+This will pick optimized implementations of some primitives, if they
+appear to work as expected after running some tests, and these will be
+used for subsequent operations. It only need to be called once.
+
+This function is not thread-safe. No other Sodium functions should be
+called until it successfully returns. In a multithreading environment,
+if, for some reason, you really need to call `sodium_init()` while some
+other Sodium functions may be running in different threads, add locks
+accordingly (both around `sodium_init()` and around other functions).
+
+Sodium also provides helper functions to generate random numbers,
+leveraging `/dev/urandom` or `/dev/random` on *nix and the cryptographic
+service provider on Windows. The interface is similar to
+`arc4random(3)`. It is `fork(2)`-safe but not thread-safe. This holds
+true for `crypto_sign_keypair()` and `crypto_box_keypair()` as well.
+
+    uint32_t randombytes_random(void);
+
+Return a random 32-bit unsigned value.
+
+    void     randombytes_stir(void);
+
+Generate a new key for the pseudorandom number generator. The file
+descriptor for the entropy source is kept open, so that the generator
+can be reseeded even in a chroot() jail.
+
+    uint32_t randombytes_uniform(const uint32_t upper_bound);
+
+Return a value between 0 and upper_bound using a uniform distribution.
+
+    void     randombytes_buf(void * const buf, const size_t size);
+
+Fill the buffer `buf` with `size` random bytes.
+
+    int      randombytes_close(void);
+
+Close the file descriptor or the handle for the cryptographic service
+provider.
+
+A custom implementation of these functions can be registered with
+`randombytes_set_implementation()`.
+
+In addition, Sodium provides a function to securely wipe a memory
+region:
+
+    void     sodium_memzero(void * const pnt, const size_t size);
+    
+Warning: if a region has been allocated on the heap, you still have
+to make sure that it can't get swapped to disk, possibly using
+`mlock(2)`.
+
+In order to compare memory zones in constant time, Sodium provides:
+
+    int      sodium_memcmp(const void * const b1_, const void * const b2_,
+                           size_t size);
+
+And a convenience function for converting a binary buffer to a
+hexadecimal string:
+
+    char *   sodium_bin2hex(char * const hex, const size_t hexlen,
+                            const unsigned char *bin, const size_t binlen);
+
+## New operations
+
+### crypto_shorthash
+
+A lot of applications and programming language implementations have
+been recently found to be vulnerable to denial-of-service attacks when
+a hash function with weak security guarantees, like Murmurhash 3, was
+used to construct a hash table.
+
+In order to address this, Sodium provides the “shorthash” function,
+currently implemented using SipHash-2-4. This very fast hash function
+outputs short, but unpredictable (without knowing the secret key)
+values suitable for picking a list in a hash table for a given key.
+
+See `crypto_shorthash.h` for details.
+
+### crypto_generichash
+
+This hash function provides:
+
+* A variable output length (up to `crypto_generichash_BYTES_MAX` bytes)
+* A variable key length (from no key at all to
+  `crypto_generichash_KEYBYTES_MAX` bytes)
+* A simple interface as well as a streaming interface.
+
+`crypto_generichash` is currently being implemented using
+[Blake2](https://blake2.net/).
+
+## Constants available as functions
+
+In addition to constants for key sizes, output sizes and block sizes,
+Sodium provides these values through function calls, so that using
+them from different languages is easier.
+
+## Bindings for other languages
+
+* Erlang: [Erlang-NaCl](https://github.com/tonyg/erlang-nacl)
+* Haskell: [Saltine](https://github.com/tel/saltine)
+* Java: [Kalium](https://github.com/abstractj/kalium)
+* Java JNI: [Kalium-JNI](https://github.com/joshjdevl/kalium-jni)
+* Julia: [Sodium.jl](https://github.com/amitmurthy/Sodium.jl)
+* Ocaml: [ocaml-sodium](https://github.com/dsheets/ocaml-sodium)
+* Pharo/Squeak: [Crypto-NaCl](http://www.eighty-twenty.org/index.cgi/tech/smalltalk/nacl-for-squeak-and-pharo-20130601.html)
+* PHP: [PHP-Sodium](https://github.com/alethia7/php-sodium)
+* Python: [PyNaCl](https://github.com/dstufft/pynacl)
+* Python: [PySodium](https://github.com/stef/pysodium)
+* Racket: part of [CRESTaceans](https://github.com/mgorlick/CRESTaceans/tree/master/bindings/libsodium)
+* Ruby: [RbNaCl](https://github.com/cryptosphere/rbnacl)
+* Ruby: [Sodium](https://github.com/stouset/sodium)
+
+## CurveCP
+
+CurveCP tools are part of a different project,
+[libchloride](https://github.com/jedisct1/libchloride).
+If you are interested in an embeddable CurveCP implementation, take a
+look at [libcurvecpr](https://github.com/impl/libcurvecpr).
+
+## Mailing list
+
+A mailing-list is available to discuss libsodium.
+
+In order to join, just send a random mail to `sodium-subscribe` {at}
+`pureftpd`{dot}`org`.
+
+## License
+
+[ISC license](http://en.wikipedia.org/wiki/ISC_license).
+
+See the `COPYING` file for details, `AUTHORS` for designers and
+implementors, and `THANKS` for contributors.
+

src/libsodium/THANKS

+@alethia7
+@joshjdevl
+@neheb
+Amit Murthy (@amitmurthy)
+Bruno Oliveira (@abstractj)
+Chris Rebert (@cvrebert)
+Donald Stufft (@dstufft)
+Douglas Campos (@qmx)
+Jeroen Habraken (@VeXocide)
+Joseph Abrahamson (@tel)
+Kenneth Ballenegger (@kballenegger)
+Michael Gorlick (@mgorlick)
+Samuel Neves (@sneves)
+Stefan Marsiske
+Stephan Touset (@stouset)
+Tony Arcieri (@bascule)
+Tony Garnock-Jones (@tonyg)

src/libsodium/autogen.sh

+#! /bin/sh
+
+if [ -x "`which autoreconf 2>/dev/null`" ] ; then
+  exec autoreconf -ivf
+fi
+
+if glibtoolize --version > /dev/null 2>&1; then
+  LIBTOOLIZE='glibtoolize'
+else
+  LIBTOOLIZE='libtoolize'
+fi
+
+$LIBTOOLIZE && \
+aclocal && \
+automake --add-missing --force-missing --include-deps && \
+autoconf

src/libsodium/compile

+#! /bin/sh
+# Wrapper for compilers which do not understand '-c -o'.
+
+scriptversion=2012-10-14.11; # UTC
+
+# Copyright (C) 1999-2013 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, see <http://www.gnu.org/licenses/>.
+
+# 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.
+
+# This file is maintained in Automake, please report
+# bugs to <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+
+nl='
+'
+
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent tools from complaining about whitespace usage.
+IFS=" ""	$nl"
+
+file_conv=
+
+# func_file_conv build_file lazy
+# Convert a $build file to $host form and store it in $file
+# Currently only supports Windows hosts. If the determined conversion
+# type is listed in (the comma separated) LAZY, no conversion will
+# take place.
+func_file_conv ()
+{
+  file=$1
+  case $file in
+    / | /[!/]*) # absolute file, and not a UNC file
+      if test -z "$file_conv"; then
+	# lazily determine how to convert abs files
+	case `uname -s` in
+	  MINGW*)
+	    file_conv=mingw
+	    ;;
+	  CYGWIN*)
+	    file_conv=cygwin
+	    ;;
+	  *)
+	    file_conv=wine
+	    ;;
+	esac
+      fi
+      case $file_conv/,$2, in
+	*,$file_conv,*)
+	  ;;
+	mingw/*)
+	  file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'`
+	  ;;
+	cygwin/*)
+	  file=`cygpath -m "$file" || echo "$file"`
+	  ;;
+	wine/*)
+	  file=`winepath -w "$file" || echo "$file"`
+	  ;;
+      esac
+      ;;
+  esac
+}
+
+# func_cl_dashL linkdir
+# Make cl look for libraries in LINKDIR
+func_cl_dashL ()
+{
+  func_file_conv "$1"
+  if test -z "$lib_path"; then
+    lib_path=$file
+  else
+    lib_path="$lib_path;$file"
+  fi
+  linker_opts="$linker_opts -LIBPATH:$file"
+}
+
+# func_cl_dashl library
+# Do a library search-path lookup for cl
+func_cl_dashl ()
+{
+  lib=$1
+  found=no
+  save_IFS=$IFS
+  IFS=';'
+  for dir in $lib_path $LIB
+  do
+    IFS=$save_IFS
+    if $shared && test -f "$dir/$lib.dll.lib"; then
+      found=yes
+      lib=$dir/$lib.dll.lib
+      break
+    fi
+    if test -f "$dir/$lib.lib"; then
+      found=yes
+      lib=$dir/$lib.lib
+      break
+    fi
+    if test -f "$dir/lib$lib.a"; then
+      found=yes
+      lib=$dir/lib$lib.a
+      break
+    fi
+  done
+  IFS=$save_IFS
+
+  if test "$found" != yes; then
+    lib=$lib.lib
+  fi
+}
+
+# func_cl_wrapper cl arg...
+# Adjust compile command to suit cl
+func_cl_wrapper ()
+{
+  # Assume a capable shell
+  lib_path=
+  shared=:
+  linker_opts=
+  for arg
+  do
+    if test -n "$eat"; then
+      eat=
+    else
+      case $1 in
+	-o)
+	  # configure might choose to run compile as 'compile cc -o foo foo.c'.
+	  eat=1
+	  case $2 in
+	    *.o | *.[oO][bB][jJ])
+	      func_file_conv "$2"
+	      set x "$@" -Fo"$file"
+	      shift
+	      ;;
+	    *)
+	      func_file_conv "$2"
+	      set x "$@" -Fe"$file"
+	      shift
+	      ;;
+	  esac
+	  ;;
+	-I)
+	  eat=1
+	  func_file_conv "$2" mingw
+	  set x "$@" -I"$file"
+	  shift
+	  ;;
+	-I*)
+	  func_file_conv "${1#-I}" mingw
+	  set x "$@" -I"$file"
+	  shift
+	  ;;
+	-l)
+	  eat=1
+	  func_cl_dashl "$2"
+	  set x "$@" "$lib"
+	  shift
+	  ;;
+	-l*)
+	  func_cl_dashl "${1#-l}"
+	  set x "$@" "$lib"
+	  shift
+	  ;;
+	-L)
+	  eat=1
+	  func_cl_dashL "$2"
+	  ;;
+	-L*)
+	  func_cl_dashL "${1#-L}"
+	  ;;
+	-static)
+	  shared=false
+	  ;;
+	-Wl,*)
+	  arg=${1#-Wl,}
+	  save_ifs="$IFS"; IFS=','
+	  for flag in $arg; do
+	    IFS="$save_ifs"
+	    linker_opts="$linker_opts $flag"
+	  done
+	  IFS="$save_ifs"
+	  ;;
+	-Xlinker)
+	  eat=1
+	  linker_opts="$linker_opts $2"
+	  ;;
+	-*)
+	  set x "$@" "$1"
+	  shift
+	  ;;
+	*.cc | *.CC | *.cxx | *.CXX | *.[cC]++)
+	  func_file_conv "$1"
+	  set x "$@" -Tp"$file"
+	  shift
+	  ;;
+	*.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.[oO])
+	  func_file_conv "$1" mingw
+	  set x "$@" "$file"
+	  shift
+	  ;;
+	*)
+	  set x "$@" "$1"
+	  shift
+	  ;;
+      esac
+    fi
+    shift
+  done
+  if test -n "$linker_opts"; then
+    linker_opts="-link$linker_opts"
+  fi
+  exec "$@" $linker_opts
+  exit 1
+}
+
+eat=
+
+case $1 in
+  '')
+     echo "$0: No command.  Try '$0 --help' for more information." 1>&2
+     exit 1;
+     ;;
+  -h | --h*)
+    cat <<\EOF
+Usage: compile [--help] [--version] PROGRAM [ARGS]
+
+Wrapper for compilers which do not understand '-c -o'.
+Remove '-o dest.o' from ARGS, run PROGRAM with the remaining
+arguments, and rename the output as expected.
+
+If you are trying to build a whole package this is not the
+right script to run: please start by reading the file 'INSTALL'.
+
+Report bugs to <bug-automake@gnu.org>.
+EOF
+    exit $?
+    ;;
+  -v | --v*)
+    echo "compile $scriptversion"
+    exit $?
+    ;;
+  cl | *[/\\]cl | cl.exe | *[/\\]cl.exe )
+    func_cl_wrapper "$@"      # Doesn't return...
+    ;;
+esac
+
+ofile=
+cfile=
+
+for arg
+do
+  if test -n "$eat"; then
+    eat=
+  else
+    case $1 in
+      -o)
+	# configure might choose to run compile as 'compile cc -o foo foo.c'.
+	# So we strip '-o arg' only if arg is an object.
+	eat=1
+	case $2 in
+	  *.o | *.obj)
+	    ofile=$2
+	    ;;
+	  *)
+	    set x "$@" -o "$2"
+	    shift
+	    ;;
+	esac
+	;;
+      *.c)
+	cfile=$1
+	set x "$@" "$1"
+	shift
+	;;
+      *)
+	set x "$@" "$1"
+	shift
+	;;
+    esac
+  fi
+  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 "$@"
+fi
+
+# Name of file we expect compiler to create.
+cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; 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.
+"$@"
+ret=$?
+
+if test -f "$cofile"; then
+  test "$cofile" = "$ofile" || mv "$cofile" "$ofile"
+elif test -f "${cofile}bj"; then
+  test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile"
+fi
+
+rmdir "$lockdir"
+exit $ret
+
+# 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-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End: