google_hash 0.0.0

data/ext/sparsehash-1.5.2/experimental/libchash.h

@@ -0,0 +1,252 @@
+/* Copyright (c) 1998 - 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: Craig Silverstein
+ *
+ *  This library is intended to be used for in-memory hash tables,
+ *  though it provides rudimentary permanent-storage capabilities.
+ *  It attempts to be fast, portable, and small.  The best algorithm
+ *  to fulfill these goals is an internal probing hashing algorithm,
+ *  as in Knuth, _Art of Computer Programming_, vol III.  Unlike
+ *  chained (open) hashing, it doesn't require a pointer for every
+ *  item, yet it is still constant time lookup in practice.
+ *
+ *  Also to save space, we let the contents (both data and key) that
+ *  you insert be a union: if the key/data is small, we store it
+ *  directly in the hashtable, otherwise we store a pointer to it.
+ *  To keep you from having to figure out which, use KEY_PTR and
+ *  PTR_KEY to convert between the arguments to these functions and
+ *  a pointer to the real data.  For instance:
+ *     char key[] = "ab", *key2;
+ *     HTItem *bck; HashTable *ht;
+ *     HashInsert(ht, PTR_KEY(ht, key), 0);
+ *     bck = HashFind(ht, PTR_KEY(ht, "ab"));
+ *     key2 = KEY_PTR(ht, bck->key);
+ *
+ *  There are a rich set of operations supported:
+ *     AllocateHashTable() -- Allocates a hashtable structure and
+ *                            returns it.
+ *        cchKey: if it's a positive number, then each key is a
+ *                fixed-length record of that length.  If it's 0,
+ *                the key is assumed to be a \0-terminated string.
+ *        fSaveKey: normally, you are responsible for allocating
+ *                  space for the key.  If this is 1, we make a
+ *                  copy of the key for you.
+ *     ClearHashTable() -- Removes everything from a hashtable
+ *     FreeHashTable() -- Frees memory used by a hashtable
+ *
+ *     HashFind() -- takes a key (use PTR_KEY) and returns the
+ *                   HTItem containing that key, or NULL if the
+ *                   key is not in the hashtable.
+ *     HashFindLast() -- returns the item found by last HashFind()
+ *     HashFindOrInsert() -- inserts the key/data pair if the key
+ *                           is not already in the hashtable, or
+ *                           returns the appropraite HTItem if it is.
+ *     HashFindOrInsertItem() -- takes key/data as an HTItem.
+ *     HashInsert() -- adds a key/data pair to the hashtable.  What
+ *                     it does if the key is already in the table
+ *                     depends on the value of SAMEKEY_OVERWRITE.
+ *     HashInsertItem() -- takes key/data as an HTItem.
+ *     HashDelete() -- removes a key/data pair from the hashtable,
+ *                     if it's there.  RETURNS 1 if it was there,
+ *                     0 else.
+ *        If you use sparse tables and never delete, the full data
+ *        space is available.  Otherwise we steal -2 (maybe -3),
+ *        so you can't have data fields with those values.
+ *     HashDeleteLast() -- deletes the item returned by the last Find().
+ *
+ *     HashFirstBucket() -- used to iterate over the buckets in a 
+ *                          hashtable.  DON'T INSERT OR DELETE WHILE
+ *                          ITERATING!  You can't nest iterations.
+ *     HashNextBucket() -- RETURNS NULL at the end of iterating.
+ *
+ *     HashSetDeltaGoalSize() -- if you're going to insert 1000 items
+ *                               at once, call this fn with arg 1000.
+ *                               It grows the table more intelligently.
+ *
+ *     HashSave() -- saves the hashtable to a file.  It saves keys ok,
+ *                   but it doesn't know how to interpret the data field,
+ *                   so if the data field is a pointer to some complex
+ *                   structure, you must send a function that takes a
+ *                   file pointer and a pointer to the structure, and
+ *                   write whatever you want to write.  It should return
+ *                   the number of bytes written.  If the file is NULL,
+ *                   it should just return the number of bytes it would
+ *                   write, without writing anything.
+ *                      If your data field is just an integer, not a
+ *                   pointer, just send NULL for the function.
+ *     HashLoad() -- loads a hashtable.  It needs a function that takes
+ *                   a file and the size of the structure, and expects
+ *                   you to read in the structure and return a pointer
+ *                   to it.  You must do memory allocation, etc.  If
+ *                   the data is just a number, send NULL.
+ *     HashLoadKeys() -- unlike HashLoad(), doesn't load the data off disk
+ *                       until needed.  This saves memory, but if you look
+ *                       up the same key a lot, it does a disk access each
+ *                       time.
+ *        You can't do Insert() or Delete() on hashtables that were loaded
+ *        from disk.
+ */
+
+#include <sys/types.h>         /* includes definition of "ulong", we hope */
+#define ulong u_long
+
+#define MAGIC_KEY             "CHsh"   /* when we save the file */
+
+#ifndef LOG_WORD_SIZE                  /* 5 for 32 bit words, 6 for 64 */
+#if defined (__LP64__) || defined (_LP64)
+#define LOG_WORD_SIZE          6       /* log_2(sizeof(ulong)) [in bits] */
+#else
+#define LOG_WORD_SIZE          5       /* log_2(sizeof(ulong)) [in bits] */
+#endif
+#endif
+
+   /* The following gives a speed/time tradeoff: how many buckets are  *
+    * in each bin.  0 gives 32 buckets/bin, which is a good number.    */
+#ifndef LOG_BM_WORDS
+#define LOG_BM_WORDS        0      /* each group has 2^L_B_W * 32 buckets */
+#endif
+
+   /* The following are all parameters that affect performance. */
+#ifndef JUMP
+#define JUMP(key, offset)   ( ++(offset) )  /* ( 1 ) for linear hashing */
+#endif
+#ifndef Table
+#define Table(x)            Sparse##x       /* Dense##x for dense tables */
+#endif
+#ifndef FAST_DELETE
+#define FAST_DELETE         0      /* if it's 1, we never shrink the ht */
+#endif
+#ifndef SAMEKEY_OVERWRITE
+#define SAMEKEY_OVERWRITE   1      /* overwrite item with our key on insert? */
+#endif
+#ifndef OCCUPANCY_PCT
+#define OCCUPANCY_PCT       0.5    /* large PCT means smaller and slower */
+#endif
+#ifndef MIN_HASH_SIZE
+#define MIN_HASH_SIZE       512    /* ht size when first created */
+#endif
+   /* When deleting a bucket, we can't just empty it (future hashes  *
+    * may fail); instead we set the data field to DELETED.  Thus you *
+    * should set DELETED to a data value you never use.  Better yet, *
+    * if you don't need to delete, define INSERT_ONLY.               */
+#ifndef INSERT_ONLY
+#define DELETED                   -2UL
+#define IS_BCK_DELETED(bck)       ( (bck) && (bck)->data == DELETED )
+#define SET_BCK_DELETED(ht, bck)  do { (bck)->data = DELETED;                \
+                                       FREE_KEY(ht, (bck)->key); } while ( 0 )
+#else
+#define IS_BCK_DELETED(bck)       0
+#define SET_BCK_DELETED(ht, bck)  \
+   do { fprintf(stderr, "Deletion not supported for insert-only hashtable\n");\
+        exit(2); } while ( 0 )
+#endif
+
+   /* We need the following only for dense buckets (Dense##x above).  *
+    * If you need to, set this to a value you'll never use for data.  */
+#define EMPTY -3UL                /* steal more of the bck->data space */
+
+
+   /* This is what an item is.  Either can be cast to a pointer. */
+typedef struct {
+   ulong data;        /* 4 bytes for data: either a pointer or an integer */
+   ulong key;         /* 4 bytes for the key: either a pointer or an int */
+} HTItem;
+
+struct Table(Bin);                            /* defined in chash.c, I hope */
+struct Table(Iterator);
+typedef struct Table(Bin)       Table;        /* Expands to SparseBin, etc */
+typedef struct Table(Iterator)  TableIterator;
+
+   /* for STORES_PTR to work ok, cchKey MUST BE DEFINED 1st, cItems 2nd! */
+typedef struct HashTable {
+   ulong cchKey;        /* the length of the key, or if it's \0 terminated */
+   ulong cItems;        /* number of items currently in the hashtable */
+   ulong cDeletedItems; /* # of buckets holding DELETE in the hashtable */
+   ulong cBuckets;      /* size of the table */
+   Table *table;        /* The actual contents of the hashtable */
+   int fSaveKeys;       /* 1 if we copy keys locally; 2 if keys in one block */
+   int cDeltaGoalSize;  /* # of coming inserts (or deletes, if <0) we expect */
+   HTItem *posLastFind; /* position of last Find() command */
+   TableIterator *iter; /* used in First/NextBucket */
+
+   FILE *fpData;        /* if non-NULL, what item->data points into */
+   char * (*dataRead)(FILE *, int);   /* how to load data from disk */
+   HTItem bckData;      /* holds data after being loaded from disk */
+} HashTable;
+
+   /* Small keys are stored and passed directly, but large keys are
+    * stored and passed as pointers.  To make it easier to remember
+    * what to pass, we provide two functions:
+    *   PTR_KEY: give it a pointer to your data, and it returns
+    *            something appropriate to send to Hash() functions or
+    *            be stored in a data field.
+    *   KEY_PTR: give it something returned by a Hash() routine, and
+    *            it returns a (char *) pointer to the actual data.
+    */
+#define HashKeySize(ht)   ( ((ulong *)(ht))[0] )  /* this is how we inline */
+#define HashSize(ht)      ( ((ulong *)(ht))[1] )  /* ...a la C++ :-) */
+
+#define STORES_PTR(ht)    ( HashKeySize(ht) == 0 || \
+			    HashKeySize(ht) > sizeof(ulong) )
+#define KEY_PTR(ht, key)  ( STORES_PTR(ht) ? (char *)(key) : (char *)&(key) )
+#ifdef DONT_HAVE_TO_WORRY_ABOUT_BUS_ERRORS
+#define PTR_KEY(ht, ptr)  ( STORES_PTR(ht) ? (ulong)(ptr) : *(ulong *)(ptr) )
+#else
+#define PTR_KEY(ht, ptr)  ( STORES_PTR(ht) ? (ulong)(ptr) : HTcopy((char *)ptr))
+#endif
+
+
+   /* Function prototypes */
+unsigned long HTcopy(char *pul);         /* for PTR_KEY, not for users */
+
+struct HashTable *AllocateHashTable(int cchKey, int fSaveKeys);
+void ClearHashTable(struct HashTable *ht);
+void FreeHashTable(struct HashTable *ht);
+
+HTItem *HashFind(struct HashTable *ht, ulong key);
+HTItem *HashFindLast(struct HashTable *ht);
+HTItem *HashFindOrInsert(struct HashTable *ht, ulong key, ulong dataInsert);
+HTItem *HashFindOrInsertItem(struct HashTable *ht, HTItem *pItem);
+
+HTItem *HashInsert(struct HashTable *ht, ulong key, ulong data);
+HTItem *HashInsertItem(struct HashTable *ht, HTItem *pItem);
+
+int HashDelete(struct HashTable *ht, ulong key);
+int HashDeleteLast(struct HashTable *ht);
+
+HTItem *HashFirstBucket(struct HashTable *ht);
+HTItem *HashNextBucket(struct HashTable *ht);
+
+int HashSetDeltaGoalSize(struct HashTable *ht, int delta);
+
+void HashSave(FILE *fp, struct HashTable *ht, int (*write)(FILE *, char *));
+struct HashTable *HashLoad(FILE *fp, char * (*read)(FILE *, int));
+struct HashTable *HashLoadKeys(FILE *fp, char * (*read)(FILE *, int));

data/ext/sparsehash-1.5.2/google-sparsehash.sln

@@ -0,0 +1,47 @@
+Microsoft Visual Studio Solution File, Format Version 8.00
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "type_traits_unittest", "vsprojects\type_traits_unittest\type_traits_unittest.vcproj", "{008CCFED-7D7B-46F8-8E13-03837A2258B3}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sparsetable_unittest", "vsprojects\sparsetable_unittest\sparsetable_unittest.vcproj", "{E420867B-8BFA-4739-99EC-E008AB762FF9}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "hashtable_unittest", "vsprojects\hashtable_unittest\hashtable_unittest.vcproj", "{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0535}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "time_hash_map", "vsprojects\time_hash_map\time_hash_map.vcproj", "{A74E5DB8-5295-487A-AB1D-23859F536F45}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfiguration) = preSolution
+		Debug = Debug
+		Release = Release
+	EndGlobalSection
+	GlobalSection(ProjectDependencies) = postSolution
+	EndGlobalSection
+	GlobalSection(ProjectConfiguration) = postSolution
+		{008CCFED-7D7B-46F8-8E13-03837A2258B3}.Debug.ActiveCfg = Debug|Win32
+		{008CCFED-7D7B-46F8-8E13-03837A2258B3}.Debug.Build.0 = Debug|Win32
+		{008CCFED-7D7B-46F8-8E13-03837A2258B3}.Release.ActiveCfg = Release|Win32
+		{008CCFED-7D7B-46F8-8E13-03837A2258B3}.Release.Build.0 = Release|Win32
+		{E420867B-8BFA-4739-99EC-E008AB762FF9}.Debug.ActiveCfg = Debug|Win32
+		{E420867B-8BFA-4739-99EC-E008AB762FF9}.Debug.Build.0 = Debug|Win32
+		{E420867B-8BFA-4739-99EC-E008AB762FF9}.Release.ActiveCfg = Release|Win32
+		{E420867B-8BFA-4739-99EC-E008AB762FF9}.Release.Build.0 = Release|Win32
+		{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0535}.Debug.ActiveCfg = Debug|Win32
+		{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0535}.Debug.Build.0 = Debug|Win32
+		{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0535}.Release.ActiveCfg = Release|Win32
+		{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0535}.Release.Build.0 = Release|Win32
+		{A74E5DB8-5295-487A-AB1D-23859F536F45}.Debug.ActiveCfg = Debug|Win32
+		{A74E5DB8-5295-487A-AB1D-23859F536F45}.Debug.Build.0 = Debug|Win32
+		{A74E5DB8-5295-487A-AB1D-23859F536F45}.Release.ActiveCfg = Release|Win32
+		{A74E5DB8-5295-487A-AB1D-23859F536F45}.Release.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+	EndGlobalSection
+	GlobalSection(ExtensibilityAddIns) = postSolution
+	EndGlobalSection
+EndGlobal

data/ext/sparsehash-1.5.2/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: