/[svn]/ircd-hybrid-7.2/ltmain.sh

Diff of /ircd-hybrid-7.2/ltmain.sh

Parent Directory | Revision Log | View Patch Patch

-revision 912 by michael,
Wed Nov  7 22:47:44 2007 UTC
+revision 945 by michael,
Mon Jul 20 15:48:27 2009 UTC
 Line 1
- # ltmain.sh - Provide generalized library-building support services.
+ # Generated from ltmain.m4sh.
- # NOTE: Changing this file will not affect anything until you rerun configure.
- #
+ # ltmain.sh (GNU libtool) 2.2.6
- # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
+ # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
- # 2007  Free Software Foundation, Inc.
- # Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+ # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc.
- #
+ # This is free software; see the source for copying conditions.  There is NO
- # This program is free software; you can redistribute it and/or modify
+ # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ # GNU Libtool 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
+ # As a special exception to the GNU General Public License,
+ # if you distribute this file as part of a program or library that
+ # is built using GNU Libtool, you may include this file under the
+ # same distribution terms that you use for the rest of that program.
+ #
+ # GNU Libtool 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
+ # along with GNU Libtool; see the file COPYING.  If not, a copy
- # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ # can be downloaded from http://www.gnu.org/licenses/gpl.html,
- #
+ # or obtained by writing to the Free Software Foundation, Inc.,
- # As a special exception to the GNU General Public License, if you
+ # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- # 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:
+ # Usage: $progname [OPTION]... [MODE-ARG]...
- progname=`echo "$progpath" | $SED $basename`
+ #
- modename="$progname"
+ # Provide generalized library-building support services.
+ #
- # Global variables:
+ #     --config             show all configuration variables
- EXIT_SUCCESS=0
+ #     --debug              enable verbose shell tracing
- EXIT_FAILURE=1
+ # -n, --dry-run            display commands without modifying any files
+ #     --features           display basic configuration information and exit
+ #     --mode=MODE          use operation mode MODE
+ #     --preserve-dup-deps  don't remove duplicate dependency libraries
+ #     --quiet, --silent    don't print informational messages
+ #     --tag=TAG            use configuration variables from tag TAG
+ # -v, --verbose            print informational messages (default)
+ #     --version            print version information
+ # -h, --help               print short or long help message
+ #
+ # 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 `$progname --help --mode=MODE' for a more detailed description of MODE.
+ #
+ # When reporting a bug, please describe a test case to reproduce it and
+ # include the following information:
+ #
+ #       host-triplet:   $host
+ #       shell:          $SHELL
+ #       compiler:               $LTCC
+ #       compiler flags:         $LTCFLAGS
+ #       linker:         $LD (gnu? $with_gnu_ld)
+ #       $progname:              (GNU libtool) 2.2.6
+ #       automake:               $automake_version
+ #       autoconf:               $autoconf_version
+ #
+ # Report bugs to <bug-libtool@gnu.org>.
  PROGRAM=ltmain.sh
  PACKAGE=libtool
- VERSION=1.5.24
+ VERSION=2.2.6
- TIMESTAMP=" (1.1220.2.455 2007/06/24 02:13:29)"
+ TIMESTAMP=""
+ package_revision=1.3012
+ # define SED for historic ltconfig's generated by Libtool 1.3
+ test -z "$SED" && SED=sed
- # Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).
+ # Be Bourne compatible
  if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
    emulate sh
    NULLCMD=:
-Line 60 
 fi
+Line 94 
 fi
  BIN_SH=xpg4; export BIN_SH # for Tru64
  DUALCASE=1; export DUALCASE # for MKS sh
- # Check that we have a working $echo.
+ # NLS nuisances: We save the old values to restore during execute mode.
- 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.
+ lt_user_locale=
- for lt_var in LANG LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
+ lt_safe_locale=
+ for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
  do
    eval "if test \"\${$lt_var+set}\" = set; then
            save_$lt_var=\$$lt_var
            $lt_var=C
            export $lt_var
+           lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
+           lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
          fi"
  done
+ $lt_unset CDPATH
+ : ${CP="cp -f"}
+ : ${ECHO="echo"}
+ : ${EGREP="/bin/grep -E"}
+ : ${FGREP="/bin/grep -F"}
+ : ${GREP="/bin/grep"}
+ : ${LN_S="ln -s"}
+ : ${MAKE="make"}
+ : ${MKDIR="mkdir"}
+ : ${MV="mv -f"}
+ : ${RM="rm -f"}
+ : ${SED="/bin/sed"}
+ : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
+ : ${Xsed="$SED -e 1s/^X//"}
+ # Global variables:
+ EXIT_SUCCESS=0
+ EXIT_FAILURE=1
+ EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
+ EXIT_SKIP=77      # $? = 77 is used to indicate a skipped test to automake.
+ exit_status=$EXIT_SUCCESS
  # Make sure IFS has a sensible default
  lt_nl='
  '
  IFS="   $lt_nl"
- if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
+ dirname="s,/[^/]*$,,"
-   $echo "$modename: not configured to build any kind of library" 1>&2
+ basename="s,^.*/,,"
-   $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
-   exit $EXIT_FAILURE
- fi
- # Global variables.
+ # func_dirname_and_basename file append nondir_replacement
- mode=$default_mode
+ # perform func_basename and func_dirname in a single function
- nonopt=
+ # call:
- prev=
+ #   dirname:  Compute the dirname of FILE.  If nonempty,
- prevopt=
+ #             add APPEND to the result, otherwise set result
- run=
+ #             to NONDIR_REPLACEMENT.
- show="$echo"
+ #             value returned in "$func_dirname_result"
- show_help=
+ #   basename: Compute filename of FILE.
- execute_dlfiles=
+ #             value retuned in "$func_basename_result"
- duplicate_deps=no
+ # Implementation must be kept synchronized with func_dirname
- preserve_args=
+ # and func_basename. For efficiency, we do not delegate to
- lo2o="s/\\.lo\$/.${objext}/"
+ # those functions but instead duplicate the functionality here.
- o2lo="s/\\.${objext}\$/.lo/"
+ func_dirname_and_basename ()
- extracted_archives=
+ {
- extracted_serial=0
+   # Extract subdirectory from the argument.
+   func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
+   if test "X$func_dirname_result" = "X${1}"; then
+     func_dirname_result="${3}"
+   else
+     func_dirname_result="$func_dirname_result${2}"
+   fi
+   func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
+ }
+ # Generated shell functions inserted here.
+ # 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:
+ # In the unlikely event $progname began with a '-', it would play havoc with
+ # func_echo (imagine progname=-n), so we prepend ./ in that case:
+ func_dirname_and_basename "$progpath"
+ progname=$func_basename_result
+ case $progname in
+   -*) progname=./$progname ;;
+ esac
+ # Make sure we have an absolute path for reexecution:
+ case $progpath in
+   [\\/]*|[A-Za-z]:\\*) ;;
+   *[\\/]*)
+      progdir=$func_dirname_result
+      progdir=`cd "$progdir" && pwd`
+      progpath="$progdir/$progname"
+      ;;
+   *)
+      save_IFS="$IFS"
+      IFS=:
+      for progdir in $PATH; do
+        IFS="$save_IFS"
+        test -x "$progdir/$progname" && break
+      done
+      IFS="$save_IFS"
+      test -n "$progdir" || progdir=`pwd`
+      progpath="$progdir/$progname"
+      ;;
+ 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'
+ # Re-`\' parameter expansions in output of double_quote_subst that were
+ # `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
+ # in input to double_quote_subst, that '$' was protected from expansion.
+ # Since each input `\' is now two `\'s, look for any number of runs of
+ # four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
+ bs='\\'
+ bs2='\\\\'
+ bs4='\\\\\\\\'
+ dollar='\$'
+ sed_double_backslash="\
+   s/$bs4/&\\
+ /g
+   s/^$bs2$dollar/$bs&/
+   s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
+   s/\n//g"
+ # Standard options:
+ opt_dry_run=false
+ opt_help=false
+ opt_quiet=false
+ opt_verbose=false
+ opt_warning=:
+ # func_echo arg...
+ # Echo program name prefixed message, along with the current mode
+ # name if it has been set yet.
+ func_echo ()
+ {
+     $ECHO "$progname${mode+: }$mode: $*"
+ }
+ # func_verbose arg...
+ # Echo program name prefixed message in verbose mode only.
+ func_verbose ()
+ {
+     $opt_verbose && func_echo ${1+"$@"}
+     # A bug in bash halts the script if the last line of a function
+     # fails when set -e is in force, so we need another command to
+     # work around that:
+     :
+ }
+ # func_error arg...
+ # Echo program name prefixed message to standard error.
+ func_error ()
+ {
+     $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
+ }
+ # func_warning arg...
+ # Echo program name prefixed warning message to standard error.
+ func_warning ()
+ {
+     $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
+     # bash bug again:
+     :
+ }
+ # func_fatal_error arg...
+ # Echo program name prefixed message to standard error, and exit.
+ func_fatal_error ()
+ {
+     func_error ${1+"$@"}
+     exit $EXIT_FAILURE
+ }
+ # func_fatal_help arg...
+ # Echo program name prefixed message to standard error, followed by
+ # a help hint, and exit.
+ func_fatal_help ()
+ {
+     func_error ${1+"$@"}
+     func_fatal_error "$help"
+ }
+ help="Try \`$progname --help' for more information."  ## default
+ # func_grep expression filename
+ # Check whether EXPRESSION matches any line of FILENAME, without output.
+ func_grep ()
+ {
+     $GREP "$1" "$2" >/dev/null 2>&1
+ }
+ # func_mkdir_p directory-path
+ # Make sure the entire path to DIRECTORY-PATH is available.
+ func_mkdir_p ()
+ {
+     my_directory_path="$1"
+     my_dir_list=
+     if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
+       # Protect directory names starting with `-'
+       case $my_directory_path in
+         -*) my_directory_path="./$my_directory_path" ;;
+       esac
+       # While some portion of DIR does not yet exist...
+       while test ! -d "$my_directory_path"; do
+         # ...make a list in topmost first order.  Use a colon delimited
+         # list incase some portion of path contains whitespace.
+         my_dir_list="$my_directory_path:$my_dir_list"
+         # If the last portion added has no slash in it, the list is done
+         case $my_directory_path in */*) ;; *) break ;; esac
+         # ...otherwise throw away the child directory and loop
+         my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
+       done
+       my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
+       save_mkdir_p_IFS="$IFS"; IFS=':'
+       for my_dir in $my_dir_list; do
+         IFS="$save_mkdir_p_IFS"
+         # mkdir can fail with a `File exist' error if two processes
+         # try to create one of the directories concurrently.  Don't
+         # stop in that case!
+         $MKDIR "$my_dir" 2>/dev/null || :
+       done
+       IFS="$save_mkdir_p_IFS"
+       # Bail out if we (or some other process) failed to create a directory.
+       test -d "$my_directory_path" || \
+         func_fatal_error "Failed to create \`$1'"
+     fi
+ }
- #####################################
- # 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
-Line 161 
 func_mktempdir ()
+Line 358 
 func_mktempdir ()
  {
      my_template="${TMPDIR-/tmp}/${1-$progname}"
-     if test "$run" = ":"; then
+     if test "$opt_dry_run" = ":"; then
        # Return a directory name, but don't create it in dry-run mode
        my_tmpdir="${my_template}-$$"
      else
-Line 170 
 func_mktempdir ()
+Line 367 
 func_mktempdir ()
        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"
+         $MKDIR "$my_tmpdir"
          umask $save_mktempdir_umask
        fi
        # If we're not in dry-run mode, bomb out on failure
-       test -d "$my_tmpdir" || {
+       test -d "$my_tmpdir" || \
-         $echo "cannot create temporary directory \`$my_tmpdir'" 1>&2
+         func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
-         exit $EXIT_FAILURE
-       }
      fi
-     $echo "X$my_tmpdir" | $Xsed
+     $ECHO "X$my_tmpdir" | $Xsed
  }
- # func_win32_libid arg
+ # func_quote_for_eval arg
- # return the library type of file 'arg'
+ # Aesthetically quote ARG to be evaled later.
- #
+ # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
- # Need a lot of goo to handle *both* DLLs and import libs
+ # is double-quoted, suitable for a subsequent eval, whereas
- # Has to be a shell function in order to 'eat' the argument
+ # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
- # that is supplied when $file_magic_command is called.
+ # which are still active within double quotes backslashified.
- func_win32_libid ()
+ func_quote_for_eval ()
  {
-   win32_libid_type="unknown"
+     case $1 in
-   win32_fileres=`file -L $1 2>/dev/null`
+       *[\\\`\"\$]*)
-   case $win32_fileres in
+         func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
-   *ar\ archive\ import\ library*) # definitely import
+       *)
-     win32_libid_type="x86 archive import"
+         func_quote_for_eval_unquoted_result="$1" ;;
-     ;;
+     esac
-   *ar\ archive*) # could be an import, or static
-     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
+     case $func_quote_for_eval_unquoted_result in
-       $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
+       # Double-quote args containing shell metacharacters to delay
-       win32_nmres=`eval $NM -f posix -A $1 | \
+       # word splitting, command substitution and and variable
-         $SED -n -e '1,100{
+       # expansion for a subsequent eval.
-                 / I /{
+       # Many Bourne shells cannot handle close brackets correctly
-                         s,.*,import,
+       # in scan sets, so we specify it separately.
-                         p
+       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
-                         q
+         func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
-                         }
+         ;;
-                 }'`
+       *)
-       case $win32_nmres in
+         func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
-       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
+ # func_quote_for_expand arg
- # Infer tagged configuration to use if any are available and
+ # Aesthetically quote ARG to be evaled later; same as above,
- # if one wasn't chosen via the "--tag" command line option.
+ # but do not quote variable references.
- # Only attempt this if the compiler in the base compile
+ func_quote_for_expand ()
- # 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
+     case $1 in
-       CC_quoted=
+       *[\\\`\"]*)
-       for arg in $CC; do
+         my_arg=`$ECHO "X$1" | $Xsed \
-         case $arg in
+             -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
-           *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
-           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
+         my_arg="$1" ;;
-           if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
+     esac
-             # Evaluate the configuration.
-             eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
+     case $my_arg in
-             CC_quoted=
+       # Double-quote args containing shell metacharacters to delay
-             for arg in $CC; do
+       # word splitting and command substitution for a subsequent eval.
-             # Double-quote args containing other shell metacharacters.
+       # Many Bourne shells cannot handle close brackets correctly
-             case $arg in
+       # in scan sets, so we specify it separately.
-               *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
+       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
-               arg="\"$arg\""
+         my_arg="\"$my_arg\""
-               ;;
+         ;;
-             esac
+     esac
-             CC_quoted="$CC_quoted $arg"
-           done
+     func_quote_for_expand_result="$my_arg"
-             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_show_eval cmd [fail_exp]
- func_extract_an_archive ()
+ # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
+ # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
+ # is given, then evaluate it.
+ func_show_eval ()
  {
-     f_ex_an_ar_dir="$1"; shift
+     my_cmd="$1"
-     f_ex_an_ar_oldlib="$1"
+     my_fail_exp="${2-:}"
-     $show "(cd $f_ex_an_ar_dir && $AR x $f_ex_an_ar_oldlib)"
+     ${opt_silent-false} || {
-     $run eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" || exit $?
+       func_quote_for_expand "$my_cmd"
-     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
+       eval "func_echo $func_quote_for_expand_result"
-      :
+     }
-     else
-       $echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2
+     if ${opt_dry_run-false}; then :; else
-       exit $EXIT_FAILURE
+       eval "$my_cmd"
+       my_status=$?
+       if test "$my_status" -eq 0; then :; else
+         eval "(exit $my_status); $my_fail_exp"
+       fi
      fi
  }
- # func_extract_archives gentop oldlib ...
- func_extract_archives ()
+ # func_show_eval_locale cmd [fail_exp]
+ # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
+ # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
+ # is given, then evaluate it.  Use the saved locale for evaluation.
+ func_show_eval_locale ()
  {
-     my_gentop="$1"; shift
+     my_cmd="$1"
-     my_oldlibs=${1+"$@"}
+     my_fail_exp="${2-:}"
-     my_oldobjs=""
-     my_xlib=""
-     my_xabs=""
-     my_xdir=""
-     my_status=""
-     $show "${rm}r $my_gentop"
+     ${opt_silent-false} || {
-     $run ${rm}r "$my_gentop"
+       func_quote_for_expand "$my_cmd"
-     $show "$mkdir $my_gentop"
+       eval "func_echo $func_quote_for_expand_result"
-     $run $mkdir "$my_gentop"
+     }
-     my_status=$?
-     if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then
+     if ${opt_dry_run-false}; then :; else
-       exit $my_status
+       eval "$lt_user_locale
+             $my_cmd"
+       my_status=$?
+       eval "$lt_safe_locale"
+       if test "$my_status" -eq 0; then :; else
+         eval "(exit $my_status); $my_fail_exp"
+       fi
      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_xlib_u=$my_xlib
-       while :; do
-         case " $extracted_archives " in
-         *" $my_xlib_u "*)
-           extracted_serial=`expr $extracted_serial + 1`
-           my_xlib_u=lt$extracted_serial-$my_xlib ;;
-         *) break ;;
-         esac
-       done
-       extracted_archives="$extracted_archives $my_xlib_u"
-       my_xdir="$my_gentop/$my_xlib_u"
-       $show "${rm}r $my_xdir"
-       $run ${rm}r "$my_xdir"
-       $show "$mkdir $my_xdir"
-       $run $mkdir "$my_xdir"
+ # func_version
-       exit_status=$?
+ # Echo version message to standard output and exit.
-       if test "$exit_status" -ne 0 && test ! -d "$my_xdir"; then
+ func_version ()
-         exit $exit_status
+ {
-       fi
+     $SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
-       case $host in
+         s/^# //
-       *-darwin*)
+         s/^# *$//
-         $show "Extracting $my_xabs"
+         s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
-         # Do not bother doing anything if just a dry run
+         p
-         if test -z "$run"; then
+      }' < "$progpath"
-           darwin_orig_dir=`pwd`
+      exit $?
-           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
+ # func_usage
- eval std_shrext=\"$shrext_cmds\"
+ # Echo short help message to standard output and exit.
+ func_usage ()
+ {
+     $SED -n '/^# Usage:/,/# -h/ {
+         s/^# //
+         s/^# *$//
+         s/\$progname/'$progname'/
+         p
+     }' < "$progpath"
+     $ECHO
+     $ECHO "run \`$progname --help | more' for full usage"
+     exit $?
+ }
- disable_libs=no
+ # func_help
+ # Echo long help message to standard output and exit.
+ func_help ()
+ {
+     $SED -n '/^# Usage:/,/# Report bugs to/ {
+         s/^# //
+         s/^# *$//
+         s*\$progname*'$progname'*
+         s*\$host*'"$host"'*
+         s*\$SHELL*'"$SHELL"'*
+         s*\$LTCC*'"$LTCC"'*
+         s*\$LTCFLAGS*'"$LTCFLAGS"'*
+         s*\$LD*'"$LD"'*
+         s/\$with_gnu_ld/'"$with_gnu_ld"'/
+         s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
+         s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
+         p
+      }' < "$progpath"
+     exit $?
+ }
- # Parse our command line options once, thoroughly.
+ # func_missing_arg argname
- while test "$#" -gt 0
+ # Echo program name prefixed message to standard error and set global
- do
+ # exit_cmd.
-   arg="$1"
+ func_missing_arg ()
+ {
+     func_error "missing argument for $1"
+     exit_cmd=exit
+ }
+ exit_cmd=:
+ # 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
-   case $arg in
+ if test "X$1" = X--fallback-echo; then
-   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
+   # used as fallback echo
-   *) optarg= ;;
+   shift
-   esac
+   cat <<EOF
+ $*
+ EOF
+   exit $EXIT_SUCCESS
+ fi
-   # If the previous option needs an argument, assign it.
+ magic="%%%MAGIC variable%%%"
-   if test -n "$prev"; then
+ magic_exe="%%%MAGIC EXE variable%%%"
-     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
+ # Global variables.
-       CC)
+ # $mode is unset
-         # Don't test for the "default" C tag, as we know, it's there, but
+ nonopt=
-         # not specially marked.
+ execute_dlfiles=
-         ;;
+ preserve_args=
-       *)
+ lo2o="s/\\.lo\$/.${objext}/"
-         if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then
+ o2lo="s/\\.${objext}\$/.lo/"
-           taglist="$taglist $tagname"
+ extracted_archives=
-           # Evaluate the configuration.
+ extracted_serial=0
-           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=
+ opt_dry_run=false
-     prevopt=
+ opt_duplicate_deps=false
-     continue
+ opt_silent=false
-   fi
+ opt_debug=:
-   # Have we seen a non-optional argument yet?
+ # If this variable is set in any of the actions, the command in it
-   case $arg in
+ # will be execed at the end.  This prevents here-documents from being
-   --help)
+ # left over by shells.
-     show_help=yes
+ exec_cmd=
-     ;;
-   --version)
+ # func_fatal_configuration arg...
-     echo "\
+ # Echo program name prefixed message to standard error, followed by
- $PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP
+ # a configuration failure hint, and exit.
+ func_fatal_configuration ()
- Copyright (C) 2007  Free Software Foundation, Inc.
+ {
- This is free software; see the source for copying conditions.  There is NO
+     func_error ${1+"$@"}
- warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+     func_error "See the $PACKAGE documentation for more information."
-     exit $?
+     func_fatal_error "Fatal configuration error."
-     ;;
+ }
+ # func_config
+ # Display the configuration for all the tags in this script.
+ func_config ()
+ {
+     re_begincf='^# ### BEGIN LIBTOOL'
+     re_endcf='^# ### END LIBTOOL'
+     # Default configuration.
+     $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
-   --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"
+       $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
      done
-     exit $?
-     ;;
-   --debug)
+     exit $?
-     $echo "$progname: enabling shell trace mode"
+ }
-     set -x
-     preserve_args="$preserve_args $arg"
-     ;;
-   --dry-run | -n)
-     run=:
-     ;;
-   --features)
+ # func_features
-     $echo "host: $host"
+ # Display the features supported by this script.
+ func_features ()
+ {
+     $ECHO "host: $host"
      if test "$build_libtool_libs" = yes; then
-       $echo "enable shared libraries"
+       $ECHO "enable shared libraries"
      else
-       $echo "disable shared libraries"
+       $ECHO "disable shared libraries"
      fi
      if test "$build_old_libs" = yes; then
-       $echo "enable static libraries"
+       $ECHO "enable static libraries"
      else
-       $echo "disable static libraries"
+       $ECHO "disable static libraries"
      fi
      exit $?
-     ;;
+ }
-   --finish) mode="finish" ;;
+ # func_enable_tag tagname
+ # Verify that TAGNAME is valid, and either flag an error and exit, or
+ # enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
+ # variable here.
+ func_enable_tag ()
+ {
+   # Global variable:
+   tagname="$1"
-   --mode) prevopt="--mode" prev=mode ;;
+   re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
-   --mode=*) mode="$optarg" ;;
+   re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
+   sed_extractcf="/$re_begincf/,/$re_endcf/p"
+   # Validate tagname.
+   case $tagname in
+     *[!-_A-Za-z0-9,/]*)
+       func_fatal_error "invalid tag name: $tagname"
+       ;;
+   esac
-   --preserve-dup-deps) duplicate_deps="yes" ;;
+   # Don't test for the "default" C tag, as we know it's
+   # there but not specially marked.
+   case $tagname in
+     CC) ;;
+     *)
+       if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
+         taglist="$taglist $tagname"
-   --quiet | --silent)
+         # Evaluate the configuration.  Be careful to quote the path
-     show=:
+         # and the sed script, to avoid splitting on whitespace, but
-     preserve_args="$preserve_args $arg"
+         # also don't use non-portable quotes within backquotes within
-     ;;
+         # quotes we have to do it in 2 steps:
+         extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
+         eval "$extractedcf"
+       else
+         func_error "ignoring unknown tag $tagname"
+       fi
+       ;;
+   esac
+ }
+ # Parse options once, thoroughly.  This comes as soon as possible in
+ # the script to make things like `libtool --version' happen quickly.
+ {
-   --tag)
+   # Shorthand for --mode=foo, only valid as the first argument
-     prevopt="--tag"
+   case $1 in
-     prev=tag
+   clean|clea|cle|cl)
-     preserve_args="$preserve_args --tag"
+     shift; set dummy --mode clean ${1+"$@"}; shift
      ;;
-   --tag=*)
+   compile|compil|compi|comp|com|co|c)
-     set tag "$optarg" ${1+"$@"}
+     shift; set dummy --mode compile ${1+"$@"}; shift
-     shift
-     prev=tag
-     preserve_args="$preserve_args --tag"
      ;;
+   execute|execut|execu|exec|exe|ex|e)
-   -dlopen)
+     shift; set dummy --mode execute ${1+"$@"}; shift
-     prevopt="-dlopen"
-     prev=execute_dlfiles
      ;;
+   finish|finis|fini|fin|fi|f)
-   -*)
+     shift; set dummy --mode finish ${1+"$@"}; shift
-     $echo "$modename: unrecognized option \`$arg'" 1>&2
-     $echo "$help" 1>&2
-     exit $EXIT_FAILURE
      ;;
+   install|instal|insta|inst|ins|in|i)
-   *)
+     shift; set dummy --mode install ${1+"$@"}; shift
-     nonopt="$arg"
+     ;;
-     break
+   link|lin|li|l)
+     shift; set dummy --mode link ${1+"$@"}; shift
+     ;;
+   uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
+     shift; set dummy --mode uninstall ${1+"$@"}; shift
      ;;
    esac
- done
- if test -n "$prevopt"; then
+   # Parse non-mode specific arguments:
-   $echo "$modename: option \`$prevopt' requires an argument" 1>&2
+   while test "$#" -gt 0; do
-   $echo "$help" 1>&2
+     opt="$1"
-   exit $EXIT_FAILURE
+     shift
- fi
- case $disable_libs in
+     case $opt in
- no)
+       --config)         func_config                                     ;;
-   ;;
- 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
+       --debug)          preserve_args="$preserve_args $opt"
- # will be execed at the end.  This prevents here-documents from being
+                         func_echo "enabling shell trace mode"
- # left over by shells.
+                         opt_debug='set -x'
- exec_cmd=
+                         $opt_debug
+                         ;;
- if test -z "$show_help"; then
+       -dlopen)          test "$#" -eq 0 && func_missing_arg "$opt" && break
+                         execute_dlfiles="$execute_dlfiles $1"
+                         shift
+                         ;;
-   # Infer the operation mode.
+       --dry-run | -n)   opt_dry_run=:                                   ;;
-   if test -z "$mode"; then
+       --features)       func_features                                   ;;
-     $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
+       --finish)         mode="finish"                                   ;;
-     $echo "*** Future versions of Libtool will require --mode=MODE be specified." 1>&2
-     case $nonopt in
+       --mode)           test "$#" -eq 0 && func_missing_arg "$opt" && break
-     *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
+                         case $1 in
-       mode=link
+                           # Valid mode arguments:
-       for arg
+                           clean)        ;;
-       do
+                           compile)      ;;
-         case $arg in
+                           execute)      ;;
-         -c)
+                           finish)       ;;
-            mode=compile
+                           install)      ;;
-            break
+                           link)         ;;
-            ;;
+                           relink)       ;;
-         esac
+                           uninstall)    ;;
-       done
-       ;;
+                           # Catch anything else as an error
-     *db | *dbx | *strace | *truss)
+                           *) func_error "invalid argument for $opt"
-       mode=execute
+                              exit_cmd=exit
-       ;;
+                              break
-     *install*|cp|mv)
+                              ;;
-       mode=install
+                         esac
-       ;;
-     *rm)
+                         mode="$1"
-       mode=uninstall
+                         shift
+                         ;;
+       --preserve-dup-deps)
+                         opt_duplicate_deps=:                            ;;
+       --quiet|--silent) preserve_args="$preserve_args $opt"
+                         opt_silent=:
+                         ;;
+       --verbose| -v)    preserve_args="$preserve_args $opt"
+                         opt_silent=false
+                         ;;
+       --tag)            test "$#" -eq 0 && func_missing_arg "$opt" && break
+                         preserve_args="$preserve_args $opt $1"
+                         func_enable_tag "$1"    # tagname is set here
+                         shift
+                         ;;
+       # Separate optargs to long options:
+       -dlopen=*|--mode=*|--tag=*)
+                         func_opt_split "$opt"
+                         set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
+                         shift
+                         ;;
+       -\?|-h)           func_usage                                      ;;
+       --help)           opt_help=:                                      ;;
+       --version)        func_version                                    ;;
+       -*)               func_fatal_help "unrecognized option \`$opt'"   ;;
+       *)                nonopt="$opt"
+                         break
+                         ;;
+     esac
+   done
+   case $host in
+     *cygwin* | *mingw* | *pw32* | *cegcc*)
+       # don't eliminate duplications in $postdeps and $predeps
+       opt_duplicate_compiler_generated_deps=:
        ;;
      *)
-       # If we have no mode, but dlfiles were specified, then do execute mode.
+       opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
-       test -n "$execute_dlfiles" && mode=execute
+       ;;
+   esac
-       # Just use the default operation mode.
+   # Having warned about all mis-specified options, bail out if
-       if test -z "$mode"; then
+   # anything was wrong.
-         if test -n "$nonopt"; then
+   $exit_cmd $EXIT_FAILURE
-           $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
+ }
-         else
-           $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
+ # func_check_version_match
-         fi
+ # Ensure that we are using m4 macros, and libtool script from the same
+ # release of libtool.
+ func_check_version_match ()
+ {
+   if test "$package_revision" != "$macro_revision"; then
+     if test "$VERSION" != "$macro_version"; then
+       if test -z "$macro_version"; then
+         cat >&2 <<_LT_EOF
+ $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
+ $progname: definition of this LT_INIT comes from an older release.
+ $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
+ $progname: and run autoconf again.
+ _LT_EOF
+       else
+         cat >&2 <<_LT_EOF
+ $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
+ $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
+ $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
+ $progname: and run autoconf again.
+ _LT_EOF
        fi
-       ;;
+     else
-     esac
+       cat >&2 <<_LT_EOF
+ $progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
+ $progname: but the definition of this LT_INIT comes from revision $macro_revision.
+ $progname: You should recreate aclocal.m4 with macros from revision $package_revision
+ $progname: of $PACKAGE $VERSION and run autoconf again.
+ _LT_EOF
+     fi
+     exit $EXIT_MISMATCH
+   fi
+ }
+ ## ----------- ##
+ ##    Main.    ##
+ ## ----------- ##
+ $opt_help || {
+   # Sanity checks first:
+   func_check_version_match
+   if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
+     func_fatal_configuration "not configured to build any kind of library"
    fi
+   test -z "$mode" && func_fatal_error "error: you must specify a MODE."
+   # Darwin sucks
+   eval std_shrext=\"$shrext_cmds\"
    # 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
+     func_error "unrecognized option \`-dlopen'"
-     $echo "$help" 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."
+   help="Try \`$progname --help --mode=$mode' for more information."
+ }
+ # func_lalib_p file
+ # True iff FILE is a libtool `.la' library or `.lo' object file.
+ # This function is only a basic sanity check; it will hardly flush out
+ # determined imposters.
+ func_lalib_p ()
+ {
+     test -f "$1" &&
+       $SED -e 4q "$1" 2>/dev/null \
+         | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
+ }
+ # func_lalib_unsafe_p file
+ # True iff FILE is a libtool `.la' library or `.lo' object file.
+ # This function implements the same check as func_lalib_p without
+ # resorting to external programs.  To this end, it redirects stdin and
+ # closes it afterwards, without saving the original file descriptor.
+ # As a safety measure, use it only where a negative result would be
+ # fatal anyway.  Works if `file' does not exist.
+ func_lalib_unsafe_p ()
+ {
+     lalib_p=no
+     if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
+         for lalib_p_l in 1 2 3 4
+         do
+             read lalib_p_line
+             case "$lalib_p_line" in
+                 \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
+             esac
+         done
+         exec 0<&5 5<&-
+     fi
+     test "$lalib_p" = yes
+ }
+ # func_ltwrapper_script_p file
+ # True iff FILE is a libtool wrapper script
+ # This function is only a basic sanity check; it will hardly flush out
+ # determined imposters.
+ func_ltwrapper_script_p ()
+ {
+     func_lalib_p "$1"
+ }
+ # func_ltwrapper_executable_p file
+ # True iff FILE is a libtool wrapper executable
+ # This function is only a basic sanity check; it will hardly flush out
+ # determined imposters.
+ func_ltwrapper_executable_p ()
+ {
+     func_ltwrapper_exec_suffix=
+     case $1 in
+     *.exe) ;;
+     *) func_ltwrapper_exec_suffix=.exe ;;
+     esac
+     $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
+ }
+ # func_ltwrapper_scriptname file
+ # Assumes file is an ltwrapper_executable
+ # uses $file to determine the appropriate filename for a
+ # temporary ltwrapper_script.
+ func_ltwrapper_scriptname ()
+ {
+     func_ltwrapper_scriptname_result=""
+     if func_ltwrapper_executable_p "$1"; then
+         func_dirname_and_basename "$1" "" "."
+         func_stripname '' '.exe' "$func_basename_result"
+         func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
+     fi
+ }
+ # func_ltwrapper_p file
+ # True iff FILE is a libtool wrapper script or wrapper executable
+ # This function is only a basic sanity check; it will hardly flush out
+ # determined imposters.
+ func_ltwrapper_p ()
+ {
+     func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
+ }
+ # func_execute_cmds commands fail_cmd
+ # Execute tilde-delimited COMMANDS.
+ # If FAIL_CMD is given, eval that upon failure.
+ # FAIL_CMD may read-access the current command in variable CMD!
+ func_execute_cmds ()
+ {
+     $opt_debug
+     save_ifs=$IFS; IFS='~'
+     for cmd in $1; do
+       IFS=$save_ifs
+       eval cmd=\"$cmd\"
+       func_show_eval "$cmd" "${2-:}"
+     done
+     IFS=$save_ifs
+ }
+ # func_source file
+ # Source FILE, adding directory component if necessary.
+ # Note that it is not necessary on cygwin/mingw to append a dot to
+ # FILE even if both FILE 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.
+ func_source ()
+ {
+     $opt_debug
+     case $1 in
+     */* | *\\*) . "$1" ;;
+     *)          . "./$1" ;;
+     esac
+ }
+ # 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 ()
+ {
+     $opt_debug
+     if test -n "$available_tags" && test -z "$tagname"; then
+       CC_quoted=
+       for arg in $CC; do
+         func_quote_for_eval "$arg"
+         CC_quoted="$CC_quoted $func_quote_for_eval_result"
+       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.
+               func_quote_for_eval "$arg"
+               CC_quoted="$CC_quoted $func_quote_for_eval_result"
+             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
+           func_echo "unable to infer tagged configuration"
+           func_fatal_error "specify a tag with \`--tag'"
+ #       else
+ #         func_verbose "using $tagname tagged configuration"
+         fi
+         ;;
+       esac
+     fi
+ }
+ # func_write_libtool_object output_name pic_name nonpic_name
+ # Create a libtool object file (analogous to a ".la" file),
+ # but don't create it if we're doing a dry run.
+ func_write_libtool_object ()
+ {
+     write_libobj=${1}
+     if test "$build_libtool_libs" = yes; then
+       write_lobj=\'${2}\'
+     else
+       write_lobj=none
+     fi
+     if test "$build_old_libs" = yes; then
+       write_oldobj=\'${3}\'
+     else
+       write_oldobj=none
+     fi
+     $opt_dry_run || {
+       cat >${write_libobj}T <<EOF
+ # $write_libobj - a libtool object file
+ # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
+ #
+ # Please DO NOT delete this file!
+ # It is necessary for linking the library.
+ # Name of the PIC object.
+ pic_object=$write_lobj
+ # Name of the non-PIC object
+ non_pic_object=$write_oldobj
+ EOF
+       $MV "${write_libobj}T" "${write_libobj}"
+     }
+ }
-   # These modes are in order of execution frequency so that they run quickly.
+ # func_mode_compile arg...
-   case $mode in
+ func_mode_compile ()
-   # libtool compile mode
+ {
-   compile)
+     $opt_debug
-     modename="$modename: compile"
      # Get the compilation command and the source file.
      base_compile=
      srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
-Line 658 
 if test -z "$show_help"; then
+Line 1112 
 if test -z "$show_help"; then
      arg_mode=normal
      libobj=
      later=
+     pie_flag=
      for arg
      do
-Line 678 
 if test -z "$show_help"; then
+Line 1133 
 if test -z "$show_help"; then
          # Accept any command-line options.
          case $arg in
          -o)
-           if test -n "$libobj" ; then
+           test -n "$libobj" && \
-             $echo "$modename: you cannot specify \`-o' more than once" 1>&2
+             func_fatal_error "you cannot specify \`-o' more than once"
-             exit $EXIT_FAILURE
-           fi
            arg_mode=target
            continue
            ;;
-         -static | -prefer-pic | -prefer-non-pic)
+         -pie | -fpie | -fPIE)
+           pie_flag="$pie_flag $arg"
+           continue
+           ;;
+         -shared | -static | -prefer-pic | -prefer-non-pic)
            later="$later $arg"
            continue
            ;;
-Line 702 
 if test -z "$show_help"; then
+Line 1160 
 if test -z "$show_help"; then
            ;;            #  replaced later.  I would guess that would be a bug.
          -Wc,*)
-           args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
+           func_stripname '-Wc,' '' "$arg"
+           args=$func_stripname_result
            lastarg=
            save_ifs="$IFS"; IFS=','
            for arg in $args; do
              IFS="$save_ifs"
+             func_quote_for_eval "$arg"
-             # Double-quote args containing other shell metacharacters.
+             lastarg="$lastarg $func_quote_for_eval_result"
-             # 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/^ //"`
+           func_stripname ' ' '' "$lastarg"
+           lastarg=$func_stripname_result
            # 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.
            #
-Line 738 
 if test -z "$show_help"; then
+Line 1190 
 if test -z "$show_help"; then
        esac    #  case $arg_mode
        # Aesthetically quote the previous argument.
-       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
+       func_quote_for_eval "$lastarg"
+       base_compile="$base_compile $func_quote_for_eval_result"
-       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"
+       func_fatal_error "you must specify an argument for -Xcompile"
-       exit $EXIT_FAILURE
        ;;
      target)
-       $echo "$modename: you must specify a target with \`-o'" 1>&2
+       func_fatal_error "you must specify a target with \`-o'"
-       exit $EXIT_FAILURE
        ;;
      *)
        # Get the name of the library object.
-       [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
+       test -z "$libobj" && {
+         func_basename "$srcfile"
+         libobj="$func_basename_result"
+       }
        ;;
      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 ;;
+     *.[cCFSifmso] | \
-     *.adb) xform=adb ;;
+     *.ada | *.adb | *.ads | *.asm | \
-     *.ads) xform=ads ;;
+     *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
-     *.asm) xform=asm ;;
+     *.[fF][09]? | *.for | *.java | *.obj | *.sx)
-     *.c++) xform=c++ ;;
+       func_xform "$libobj"
-     *.cc) xform=cc ;;
+       libobj=$func_xform_result
-     *.ii) xform=ii ;;
+       ;;
-     *.class) xform=class ;;
-     *.cpp) xform=cpp ;;
-     *.cxx) xform=cxx ;;
-     *.[fF][09]?) xform=[fF][09]. ;;
-     *.for) xform=for ;;
-     *.java) xform=java ;;
-     *.obj) xform=obj ;;
      esac
-     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
      case $libobj in
-     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
+     *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
      *)
-       $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
+       func_fatal_error "cannot determine name of library object from \`$libobj'"
-       exit $EXIT_FAILURE
        ;;
      esac
-Line 804 
 if test -z "$show_help"; then
+Line 1233 
 if test -z "$show_help"; then
      for arg in $later; do
        case $arg in
+       -shared)
+         test "$build_libtool_libs" != yes && \
+           func_fatal_configuration "can not build a shared library"
+         build_old_libs=no
+         continue
+         ;;
        -static)
+         build_libtool_libs=no
          build_old_libs=yes
          continue
          ;;
-Line 821 
 if test -z "$show_help"; then
+Line 1258 
 if test -z "$show_help"; then
        esac
      done
-     qlibobj=`$echo "X$libobj" | $Xsed -e "$sed_quote_subst"`
+     func_quote_for_eval "$libobj"
-     case $qlibobj in
+     test "X$libobj" != "X$func_quote_for_eval_result" \
-       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
+       && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'    &()|`$[]' \
-         qlibobj="\"$qlibobj\"" ;;
+       && func_warning "libobj name \`$libobj' may not contain shell special characters."
-     esac
+     func_dirname_and_basename "$obj" "/" ""
-     test "X$libobj" != "X$qlibobj" \
+     objname="$func_basename_result"
-         && $echo "X$libobj" | grep '[]~#^*{};<>?"'"'"'  &()|`$[]' \
+     xdir="$func_dirname_result"
-         && $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
+     test -z "$base_compile" && \
-       $echo "$modename: you must specify a compilation command" 1>&2
+       func_fatal_help "you must specify a compilation command"
-       $echo "$help" 1>&2
-       exit $EXIT_FAILURE
-     fi
      # Delete any leftover library objects.
      if test "$build_old_libs" = yes; then
-Line 851 
 if test -z "$show_help"; then
+Line 1277 
 if test -z "$show_help"; then
        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*)
+     cygwin* | mingw* | pw32* | os2* | cegcc*)
        pic_mode=default
        ;;
      esac
-Line 868 
 if test -z "$show_help"; then
+Line 1291 
 if test -z "$show_help"; then
      # 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}
+       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
-Line 881 
 if test -z "$show_help"; then
+Line 1302 
 if test -z "$show_help"; then
      # 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
+       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
-         $show "Waiting for $lockfile to be removed"
+         func_echo "Waiting for $lockfile to be removed"
          sleep 2
        done
      elif test "$need_locks" = warn; then
        if test -f "$lockfile"; then
-         $echo "\
+         $ECHO "\
  *** ERROR, $lockfile exists and contains:
  `cat $lockfile 2>/dev/null`
-Line 898 
 repeat this compilation, it may succeed,
+Line 1319 
 repeat this compilation, it may succeed,
  avoid parallel builds (make -j) in this platform, or get a better
  compiler."
-         $run $rm $removelist
+         $opt_dry_run || $RM $removelist
          exit $EXIT_FAILURE
        fi
-       $echo "$srcfile" > "$lockfile"
+       removelist="$removelist $output_obj"
+       $ECHO "$srcfile" > "$lockfile"
      fi
+     $opt_dry_run || $RM $removelist
+     removelist="$removelist $lockfile"
+     trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
      if test -n "$fix_srcfile_path"; then
        eval srcfile=\"$fix_srcfile_path\"
      fi
-     qsrcfile=`$echo "X$srcfile" | $Xsed -e "$sed_quote_subst"`
+     func_quote_for_eval "$srcfile"
-     case $qsrcfile in
+     qsrcfile=$func_quote_for_eval_result
-       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
-       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
-Line 939 
 EOF
+Line 1348 
 EOF
          command="$base_compile $qsrcfile"
        fi
-       if test ! -d "${xdir}$objdir"; then
+       func_mkdir_p "$xdir$objdir"
-         $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"
+       func_show_eval_locale "$command"  \
+           'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
-       $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 "\
+         $ECHO "\
  *** ERROR, $lockfile contains:
  `cat $lockfile 2>/dev/null`
-Line 978 
 repeat this compilation, it may succeed,
+Line 1374 
 repeat this compilation, it may succeed,
  avoid parallel builds (make -j) in this platform, or get a better
  compiler."
-         $run $rm $removelist
+         $opt_dry_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"
+         func_show_eval '$MV "$output_obj" "$lobj"' \
-         if $run $mv $output_obj $lobj; then :
+           'error=$?; $opt_dry_run || $RM $removelist; exit $error'
-         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"
+         command="$base_compile $qsrcfile$pie_flag"
        else
          command="$base_compile $qsrcfile $pic_flag"
        fi
-Line 1026 
 EOF
+Line 1404 
 EOF
        # Suppress compiler output if we already did a PIC compilation.
        command="$command$suppress_output"
-       $run $rm "$obj" "$output_obj"
+       func_show_eval_locale "$command" \
-       $show "$command"
+         '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
-       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 "\
+         $ECHO "\
  *** ERROR, $lockfile contains:
  `cat $lockfile 2>/dev/null`
-Line 1050 
 repeat this compilation, it may succeed,
+Line 1423 
 repeat this compilation, it may succeed,
  avoid parallel builds (make -j) in this platform, or get a better
  compiler."
-         $run $rm $removelist
+         $opt_dry_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"
+         func_show_eval '$MV "$output_obj" "$obj"' \
-         if $run $mv $output_obj $obj; then :
+           'error=$?; $opt_dry_run || $RM $removelist; exit $error'
+       fi
+     fi
+     $opt_dry_run || {
+       func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
+       # Unlock the critical section if it was locked
+       if test "$need_locks" != no; then
+         removelist=$lockfile
+         $RM "$lockfile"
+       fi
+     }
+     exit $EXIT_SUCCESS
+ }
+ $opt_help || {
+ test "$mode" = compile && func_mode_compile ${1+"$@"}
+ }
+ func_mode_help ()
+ {
+     # We need to display help for each of the modes.
+     case $mode in
+       "")
+         # Generic help is extracted from the usage comments
+         # at the start of this file.
+         func_help
+         ;;
+       clean)
+         $ECHO \
+ "Usage: $progname [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: $progname [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
+   -no-suppress      do not suppress compiler output for multiple passes
+   -prefer-pic       try to building PIC objects only
+   -prefer-non-pic   try to building non-PIC objects only
+   -shared           do not build a \`.o' file suitable for static linking
+   -static           only 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: $progname [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: $progname [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: $progname [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 following components of INSTALL-COMMAND are treated specially:
+   -inst-prefix PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
+ The rest of the components are interpreted as arguments to that command (only
+ BSD-compatible install options are recognized)."
+         ;;
+       link)
+         $ECHO \
+ "Usage: $progname [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
+   -shared           only do dynamic linking of libtool libraries
+   -shrext SUFFIX    override the standard shared library file extension
+   -static           do not do any dynamic linking of uninstalled libtool libraries
+   -static-libtool-libs
+                     do not do any dynamic linking of libtool libraries
+   -version-info CURRENT[:REVISION[:AGE]]
+                     specify library version info [each variable defaults to 0]
+   -weak LIBNAME     declare that the target provides the LIBNAME interface
+ 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: $progname [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."
+         ;;
+       *)
+         func_fatal_help "invalid operation mode \`$mode'"
+         ;;
+     esac
+     $ECHO
+     $ECHO "Try \`$progname --help' for more information about other modes."
+     exit $?
+ }
+   # Now that we've collected a possible --mode arg, show help if necessary
+   $opt_help && func_mode_help
+ # func_mode_execute arg...
+ func_mode_execute ()
+ {
+     $opt_debug
+     # The first argument is the command name.
+     cmd="$nonopt"
+     test -z "$cmd" && \
+       func_fatal_help "you must specify a COMMAND"
+     # Handle -dlopen flags immediately.
+     for file in $execute_dlfiles; do
+       test -f "$file" \
+         || func_fatal_help "\`$file' is not a file"
+       dir=
+       case $file in
+       *.la)
+         # Check to see that this really is a libtool archive.
+         func_lalib_unsafe_p "$file" \
+           || func_fatal_help "\`$lib' is not a valid libtool archive"
+         # Read the libtool library.
+         dlname=
+         library_names=
+         func_source "$file"
+         # Skip this library if it cannot be dlopened.
+         if test -z "$dlname"; then
+           # Warn if it was a shared library.
+           test -n "$library_names" && \
+             func_warning "\`$file' was not linked with \`-export-dynamic'"
+           continue
+         fi
+         func_dirname "$file" "" "."
+         dir="$func_dirname_result"
+         if test -f "$dir/$objdir/$dlname"; then
+           dir="$dir/$objdir"
          else
-           error=$?
+           if test ! -f "$dir/$dlname"; then
-           $run $rm $removelist
+             func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
-           exit $error
+           fi
          fi
+         ;;
+       *.lo)
+         # Just add the directory containing the .lo file.
+         func_dirname "$file" "" "."
+         dir="$func_dirname_result"
+         ;;
+       *)
+         func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
+         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
-       # Append the name of the non-PIC object the libtool object file.
+     # This variable tells wrapper scripts just to set shlibpath_var
-       # Only append if the libtool object file exists.
+     # rather than running their programs.
-       test -z "$run" && cat >> ${libobj}T <<EOF
+     libtool_execute_magic="$magic"
- # Name of the non-PIC object.
- non_pic_object='$objname'
- EOF
+     # 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 func_ltwrapper_script_p "$file"; then
+           func_source "$file"
+           # Transform arg to wrapped name.
+           file="$progdir/$program"
+         elif func_ltwrapper_executable_p "$file"; then
+           func_ltwrapper_scriptname "$file"
+           func_source "$func_ltwrapper_scriptname_result"
+           # Transform arg to wrapped name.
+           file="$progdir/$program"
+         fi
+         ;;
+       esac
+       # Quote arguments (to preserve shell metacharacters).
+       func_quote_for_eval "$file"
+       args="$args $func_quote_for_eval_result"
+     done
+     if test "X$opt_dry_run" = Xfalse; then
+       if test -n "$shlibpath_var"; then
+         # Export the shlibpath_var.
+         eval "export $shlibpath_var"
+       fi
+       # Restore saved environment variables
+       for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
+       do
+         eval "if test \"\${save_$lt_var+set}\" = set; then
+                 $lt_var=\$save_$lt_var; export $lt_var
+               else
+                 $lt_unset $lt_var
+               fi"
+       done
+       # Now prepare to actually exec the command.
+       exec_cmd="\$cmd$args"
      else
-       # Append the name of the non-PIC object the libtool object file.
+       # Display what would be done.
-       # Only append if the libtool object file exists.
+       if test -n "$shlibpath_var"; then
-       test -z "$run" && cat >> ${libobj}T <<EOF
+         eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
- # Name of the non-PIC object.
+         $ECHO "export $shlibpath_var"
- non_pic_object=none
+       fi
+       $ECHO "$cmd$args"
+       exit $EXIT_SUCCESS
+     fi
+ }
- EOF
+ test "$mode" = execute && func_mode_execute ${1+"$@"}
+ # func_mode_finish arg...
+ func_mode_finish ()
+ {
+     $opt_debug
+     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.
+           func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
+ '"$cmd"'"'
+         fi
+         if test -n "$finish_eval"; then
+           # Do the single finish_eval.
+           eval cmds=\"$finish_eval\"
+           $opt_dry_run || eval "$cmds" || admincmds="$admincmds
+        $cmds"
+         fi
+       done
      fi
-     $run $mv "${libobj}T" "${libobj}"
+     # Exit here if they wanted silent mode.
+     $opt_silent && 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\"
-     # Unlock the critical section if it was locked
+       $ECHO "   - use the \`$flag' linker flag"
-     if test "$need_locks" != no; then
+     fi
-       $run $rm "$lockfile"
+     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"
+     case $host in
+       solaris2.[6789]|solaris2.1[0-9])
+         $ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
+         $ECHO "pages."
+         ;;
+       *)
+         $ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
+         ;;
+     esac
+     $ECHO "X----------------------------------------------------------------------" | $Xsed
      exit $EXIT_SUCCESS
+ }
+ test "$mode" = finish && func_mode_finish ${1+"$@"}
+ # func_mode_install arg...
+ func_mode_install ()
+ {
+     $opt_debug
+     # 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.
+       func_quote_for_eval "$nonopt"
+       install_prog="$func_quote_for_eval_result "
+       arg=$1
+       shift
+     else
+       install_prog=
+       arg=$nonopt
+     fi
+     # The real first argument should be the name of the installation program.
+     # Aesthetically quote it.
+     func_quote_for_eval "$arg"
+     install_prog="$install_prog$func_quote_for_eval_result"
+     # 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.
+       func_quote_for_eval "$arg"
+       install_prog="$install_prog $func_quote_for_eval_result"
+     done
+     test -z "$install_prog" && \
+       func_fatal_help "you must specify an install program"
+     test -n "$prev" && \
+       func_fatal_help "the \`$prev' option requires an argument"
+     if test -z "$files"; then
+       if test -z "$dest"; then
+         func_fatal_help "no file or destination specified"
+       else
+         func_fatal_help "you must specify a destination"
+       fi
+     fi
+     # Strip any trailing slash from the destination.
+     func_stripname '' '/' "$dest"
+     dest=$func_stripname_result
+     # Check to see that the destination is a directory.
+     test -d "$dest" && isdir=yes
+     if test "$isdir" = yes; then
+       destdir="$dest"
+       destname=
+     else
+       func_dirname_and_basename "$dest" "" "."
+       destdir="$func_dirname_result"
+       destname="$func_basename_result"
+       # Not a directory, so check to see that there is only one file specified.
+       set dummy $files; shift
+       test "$#" -gt 1 && \
+         func_fatal_help "\`$dest' is not a directory"
+     fi
+     case $destdir in
+     [\\/]* | [A-Za-z]:[\\/]*) ;;
+     *)
+       for file in $files; do
+         case $file in
+         *.lo) ;;
+         *)
+           func_fatal_help "\`$destdir' must be an absolute directory name"
+           ;;
+         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.
+         func_lalib_unsafe_p "$file" \
+           || func_fatal_help "\`$file' is not a valid libtool archive"
+         library_names=
+         old_library=
+         relink_command=
+         func_source "$file"
+         # 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
+         func_dirname "$file" "/" ""
+         dir="$func_dirname_result"
+         dir="$dir$objdir"
+         if test -n "$relink_command"; then
+           # Determine the prefix the user has applied to our future dir.
+           inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "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.
+           test "$inst_prefix_dir" = "$destdir" && \
+             func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
+           if test -n "$inst_prefix_dir"; then
+             # Stick the inst_prefix_dir data into the link command.
+             relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
+           else
+             relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
+           fi
+           func_warning "relinking \`$file'"
+           func_show_eval "$relink_command" \
+             'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
+         fi
+         # See the names of the shared library.
+         set dummy $library_names; shift
+         if test -n "$1"; then
+           realname="$1"
+           shift
+           srcname="$realname"
+           test -n "$relink_command" && srcname="$realname"T
+           # Install the shared library and build the symlinks.
+           func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
+               'exit $?'
+           tstripme="$stripme"
+           case $host_os in
+           cygwin* | mingw* | pw32* | cegcc*)
+             case $realname in
+             *.dll.a)
+               tstripme=""
+               ;;
+             esac
+             ;;
+           esac
+           if test -n "$tstripme" && test -n "$striplib"; then
+             func_show_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
+               test "$linkname" != "$realname" \
+                 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
+             done
+           fi
+           # Do each command in the postinstall commands.
+           lib="$destdir/$realname"
+           func_execute_cmds "$postinstall_cmds" 'exit $?'
+         fi
+         # Install the pseudo-library for information purposes.
+         func_basename "$file"
+         name="$func_basename_result"
+         instname="$dir/$name"i
+         func_show_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
+           func_basename "$file"
+           destfile="$func_basename_result"
+           destfile="$destdir/$destfile"
+         fi
+         # Deduce the name of the destination old-style object file.
+         case $destfile in
+         *.lo)
+           func_lo2o "$destfile"
+           staticdest=$func_lo2o_result
+           ;;
+         *.$objext)
+           staticdest="$destfile"
+           destfile=
+           ;;
+         *)
+           func_fatal_help "cannot copy a libtool object to \`$destfile'"
+           ;;
+         esac
+         # Install the libtool object if requested.
+         test -n "$destfile" && \
+           func_show_eval "$install_prog $file $destfile" 'exit $?'
+         # Install the old object if enabled.
+         if test "$build_old_libs" = yes; then
+           # Deduce the name of the old-style object file.
+           func_lo2o "$file"
+           staticobj=$func_lo2o_result
+           func_show_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
+           func_basename "$file"
+           destfile="$func_basename_result"
+           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
+               func_stripname '' '.exe' "$file"
+               file=$func_stripname_result
+               stripped_ext=".exe"
+             fi
+             ;;
+         esac
+         # Do a test to see if this is really a libtool program.
+         case $host in
+         *cygwin* | *mingw*)
+             if func_ltwrapper_executable_p "$file"; then
+               func_ltwrapper_scriptname "$file"
+               wrapper=$func_ltwrapper_scriptname_result
+             else
+               func_stripname '' '.exe' "$file"
+               wrapper=$func_stripname_result
+             fi
+             ;;
+         *)
+             wrapper=$file
+             ;;
+         esac
+         if func_ltwrapper_script_p "$wrapper"; then
+           notinst_deplibs=
+           relink_command=
+           func_source "$wrapper"
+           # Check the variables that should have been set.
+           test -z "$generated_by_libtool_version" && \
+             func_fatal_error "invalid libtool wrapper script \`$wrapper'"
+           finalize=yes
+           for lib in $notinst_deplibs; do
+             # Check to see that each library is installed.
+             libdir=
+             if test -f "$lib"; then
+               func_source "$lib"
+             fi
+             libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
+             if test -n "$libdir" && test ! -f "$libfile"; then
+               func_warning "\`$lib' has not been installed in \`$libdir'"
+               finalize=no
+             fi
+           done
+           relink_command=
+           func_source "$wrapper"
+           outputname=
+           if test "$fast_install" = no && test -n "$relink_command"; then
+             $opt_dry_run || {
+               if test "$finalize" = yes; then
+                 tmpdir=`func_mktempdir`
+                 func_basename "$file$stripped_ext"
+                 file="$func_basename_result"
+                 outputname="$tmpdir/$file"
+                 # Replace the output file specification.
+                 relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
+                 $opt_silent || {
+                   func_quote_for_expand "$relink_command"
+                   eval "func_echo $func_quote_for_expand_result"
+                 }
+                 if eval "$relink_command"; then :
+                   else
+                   func_error "error: relink \`$file' with the above command before installing it"
+                   $opt_dry_run || ${RM}r "$tmpdir"
+                   continue
+                 fi
+                 file="$outputname"
+               else
+                 func_warning "cannot relink \`$file'"
+               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)
+             func_stripname '' '.exe' "$destfile"
+             destfile=$func_stripname_result
+             ;;
+           esac
+           ;;
+         esac
+         func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
+         $opt_dry_run || if test -n "$outputname"; then
+           ${RM}r "$tmpdir"
+         fi
+         ;;
+       esac
+     done
+     for file in $staticlibs; do
+       func_basename "$file"
+       name="$func_basename_result"
+       # Set up the ranlib parameters.
+       oldlib="$destdir/$name"
+       func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
+       if test -n "$stripme" && test -n "$old_striplib"; then
+         func_show_eval "$old_striplib $oldlib" 'exit $?'
+       fi
+       # Do each command in the postinstall commands.
+       func_execute_cmds "$old_postinstall_cmds" 'exit $?'
+     done
+     test -n "$future_libdirs" && \
+       func_warning "remember to run \`$progname --finish$future_libdirs'"
+     if test -n "$current_libdirs"; then
+       # Maybe just do a dry run.
+       $opt_dry_run && current_libdirs=" -n$current_libdirs"
+       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
+     else
+       exit $EXIT_SUCCESS
+     fi
+ }
+ test "$mode" = install && func_mode_install ${1+"$@"}
+ # func_generate_dlsyms outputname originator pic_p
+ # Extract symbols from dlprefiles and create ${outputname}S.o with
+ # a dlpreopen symbol table.
+ func_generate_dlsyms ()
+ {
+     $opt_debug
+     my_outputname="$1"
+     my_originator="$2"
+     my_pic_p="${3-no}"
+     my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
+     my_dlsyms=
+     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+       if test -n "$NM" && test -n "$global_symbol_pipe"; then
+         my_dlsyms="${my_outputname}S.c"
+       else
+         func_error "not configured to extract global symbols from dlpreopened files"
+       fi
+     fi
+     if test -n "$my_dlsyms"; then
+       case $my_dlsyms in
+       "") ;;
+       *.c)
+         # Discover the nlist of each of the dlfiles.
+         nlist="$output_objdir/${my_outputname}.nm"
+         func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
+         # Parse the name list into a source file.
+         func_verbose "creating $output_objdir/$my_dlsyms"
+         $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
+ /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
+ /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
+ #ifdef __cplusplus
+ extern \"C\" {
+ #endif
+ /* External symbol declarations for the compiler. */\
+ "
+         if test "$dlself" = yes; then
+           func_verbose "generating symbol list for \`$output'"
+           $opt_dry_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 progfile in $progfiles; do
+             func_verbose "extracting global C symbols from \`$progfile'"
+             $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
+           done
+           if test -n "$exclude_expsyms"; then
+             $opt_dry_run || {
+               eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
+               eval '$MV "$nlist"T "$nlist"'
+             }
+           fi
+           if test -n "$export_symbols_regex"; then
+             $opt_dry_run || {
+               eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
+               eval '$MV "$nlist"T "$nlist"'
+             }
+           fi
+           # Prepare the list of exported symbols
+           if test -z "$export_symbols"; then
+             export_symbols="$output_objdir/$outputname.exp"
+             $opt_dry_run || {
+               $RM $export_symbols
+               eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
+               case $host in
+               *cygwin* | *mingw* | *cegcc* )
+                 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+                 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
+                 ;;
+               esac
+             }
+           else
+             $opt_dry_run || {
+               eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
+               eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
+               eval '$MV "$nlist"T "$nlist"'
+               case $host in
+                 *cygwin | *mingw* | *cegcc* )
+                   eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+                   eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
+                   ;;
+               esac
+             }
+           fi
+         fi
+         for dlprefile in $dlprefiles; do
+           func_verbose "extracting global C symbols from \`$dlprefile'"
+           func_basename "$dlprefile"
+           name="$func_basename_result"
+           $opt_dry_run || {
+             eval '$ECHO ": $name " >> "$nlist"'
+             eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
+           }
+         done
+         $opt_dry_run || {
+           # 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/$my_dlsyms"'
+           else
+             $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
+           fi
+           $ECHO >> "$output_objdir/$my_dlsyms" "\
+ /* The mapping between symbol names and symbols.  */
+ typedef struct {
+   const char *name;
+   void *address;
+ } lt_dlsymlist;
+ "
+           case $host in
+           *cygwin* | *mingw* | *cegcc* )
+             $ECHO >> "$output_objdir/$my_dlsyms" "\
+ /* DATA imports from DLLs on WIN32 con't be const, because
+    runtime relocations are performed -- see ld's documentation
+    on pseudo-relocs.  */"
+             lt_dlsym_const= ;;
+           *osf5*)
+             echo >> "$output_objdir/$my_dlsyms" "\
+ /* This system does not cope well with relocations in const data */"
+             lt_dlsym_const= ;;
+           *)
+             lt_dlsym_const=const ;;
+           esac
+           $ECHO >> "$output_objdir/$my_dlsyms" "\
+ extern $lt_dlsym_const lt_dlsymlist
+ lt_${my_prefix}_LTX_preloaded_symbols[];
+ $lt_dlsym_const lt_dlsymlist
+ lt_${my_prefix}_LTX_preloaded_symbols[] =
+ {\
+   { \"$my_originator\", (void *) 0 },"
+           case $need_lib_prefix in
+           no)
+             eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
+             ;;
+           *)
+             eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
+             ;;
+           esac
+           $ECHO >> "$output_objdir/$my_dlsyms" "\
+   {0, (void *) 0}
+ };
+ /* This works around a problem in FreeBSD linker */
+ #ifdef FREEBSD_WORKAROUND
+ static const void *lt_preloaded_setup() {
+   return lt_${my_prefix}_LTX_preloaded_symbols;
+ }
+ #endif
+ #ifdef __cplusplus
+ }
+ #endif\
+ "
+         } # !$opt_dry_run
+         pic_flag_for_symtable=
+         case "$compile_command " in
+         *" -static "*) ;;
+         *)
+           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*)
+             pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
+           *-*-hpux*)
+             pic_flag_for_symtable=" $pic_flag"  ;;
+           *)
+             if test "X$my_pic_p" != Xno; then
+               pic_flag_for_symtable=" $pic_flag"
+             fi
+             ;;
+           esac
+           ;;
+         esac
+         symtab_cflags=
+         for arg in $LTCFLAGS; do
+           case $arg in
+           -pie | -fpie | -fPIE) ;;
+           *) symtab_cflags="$symtab_cflags $arg" ;;
+           esac
+         done
+         # Now compile the dynamic symbol file.
+         func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
+         # Clean up the generated files.
+         func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
+         # Transform the symbol file into the correct name.
+         symfileobj="$output_objdir/${my_outputname}S.$objext"
+         case $host in
+         *cygwin* | *mingw* | *cegcc* )
+           if test -f "$output_objdir/$my_outputname.def"; then
+             compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
+             finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
+           else
+             compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
+             finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
+           fi
+           ;;
+         *)
+           compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
+           finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
+           ;;
+         esac
+         ;;
+       *)
+         func_fatal_error "unknown suffix for \`$my_dlsyms'"
+         ;;
+       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
+ }
+ # 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 ()
+ {
+   $opt_debug
+   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 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
+       win32_nmres=`eval $NM -f posix -A $1 |
+         $SED -n -e '
+,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_extract_an_archive dir oldlib
+ func_extract_an_archive ()
+ {
+     $opt_debug
+     f_ex_an_ar_dir="$1"; shift
+     f_ex_an_ar_oldlib="$1"
+     func_show_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
+       func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
+     fi
+ }
+ # func_extract_archives gentop oldlib ...
+ func_extract_archives ()
+ {
+     $opt_debug
+     my_gentop="$1"; shift
+     my_oldlibs=${1+"$@"}
+     my_oldobjs=""
+     my_xlib=""
+     my_xabs=""
+     my_xdir=""
+     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
+       func_basename "$my_xlib"
+       my_xlib="$func_basename_result"
+       my_xlib_u=$my_xlib
+       while :; do
+         case " $extracted_archives " in
+         *" $my_xlib_u "*)
+           func_arith $extracted_serial + 1
+           extracted_serial=$func_arith_result
+           my_xlib_u=lt$extracted_serial-$my_xlib ;;
+         *) break ;;
+         esac
+       done
+       extracted_archives="$extracted_archives $my_xlib_u"
+       my_xdir="$my_gentop/$my_xlib_u"
+       func_mkdir_p "$my_xdir"
+       case $host in
+       *-darwin*)
+         func_verbose "Extracting $my_xabs"
+         # Do not bother doing anything if just a dry run
+         $opt_dry_run || {
+           darwin_orig_dir=`pwd`
+           cd $my_xdir || exit $?
+           darwin_archive=$my_xabs
+           darwin_curdir=`pwd`
+           darwin_base_archive=`basename "$darwin_archive"`
+           darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
+           if test -n "$darwin_arches"; then
+             darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
+             darwin_arch=
+             func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
+             for darwin_arch in  $darwin_arches ; do
+               func_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've a bunch of thin objects, gotta fatten them up :)
+             darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
+             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 -rf unfat-$$
+             cd "$darwin_orig_dir"
+           else
+             cd $darwin_orig_dir
+             func_extract_an_archive "$my_xdir" "$my_xabs"
+           fi # $darwin_arches
+         } # !$opt_dry_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"
+ }
+ # func_emit_wrapper_part1 [arg=no]
+ #
+ # Emit the first part of a libtool wrapper script on stdout.
+ # For more information, see the description associated with
+ # func_emit_wrapper(), below.
+ func_emit_wrapper_part1 ()
+ {
+         func_emit_wrapper_part1_arg1=no
+         if test -n "$1" ; then
+           func_emit_wrapper_part1_arg1=$1
+         fi
+         $ECHO "\
+ #! $SHELL
+ # $output - temporary wrapper script for $objdir/$outputname
+ # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
+ #
+ # 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'
+ # 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+\"\$@\"}'='\"\$@\"'
+   setopt NO_GLOB_SUBST
+ else
+   case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
+ fi
+ BIN_SH=xpg4; export BIN_SH # for Tru64
+ DUALCASE=1; export DUALCASE # for MKS sh
+ # 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 variables:
+   generated_by_libtool_version='$macro_version'
+   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 "\
+   # 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
+ "
+ }
+ # end: func_emit_wrapper_part1
+ # func_emit_wrapper_part2 [arg=no]
+ #
+ # Emit the second part of a libtool wrapper script on stdout.
+ # For more information, see the description associated with
+ # func_emit_wrapper(), below.
+ func_emit_wrapper_part2 ()
+ {
+         func_emit_wrapper_part2_arg1=no
+         if test -n "$1" ; then
+           func_emit_wrapper_part2_arg1=$1
+         fi
+         $ECHO "\
+   # Usually 'no', except on cygwin/mingw when embedded into
+   # the cwrapper.
+   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
+   if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
+     # special case for '.'
+     if test \"\$thisdir\" = \".\"; then
+       thisdir=\`pwd\`
+     fi
+     # remove .libs from thisdir
+     case \"\$thisdir\" in
+     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
+     $objdir )   thisdir=. ;;
+     esac
+   fi
+   # Try to get the absolute directory name.
+   absdir=\`cd \"\$thisdir\" && pwd\`
+   test -n \"\$absdir\" && thisdir=\"\$absdir\"
+ "
+         if test "$fast_install" = yes; then
+           $ECHO "\
+   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 "\
+     # 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 1
+       fi
+     fi
+     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
+     { $RM \"\$progdir/\$program\";
+       $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
+     $RM \"\$progdir/\$file\"
+   fi"
+         else
+           $ECHO "\
+   program='$outputname'
+   progdir=\"\$thisdir/$objdir\"
+ "
+         fi
+         $ECHO "\
+   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 "\
+     # 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 "\
+     # Add the dll search path components to the executable PATH
+     PATH=$dllsearchpath:\$PATH
+ "
+         fi
+         $ECHO "\
+     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* | *-cegcc*)
+           $ECHO "\
+       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
+ "
+           ;;
+         *)
+           $ECHO "\
+       exec \"\$progdir/\$program\" \${1+\"\$@\"}
+ "
+           ;;
+         esac
+         $ECHO "\
+       \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
+       exit 1
+     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 1
+   fi
+ fi\
+ "
+ }
+ # end: func_emit_wrapper_part2
+ # func_emit_wrapper [arg=no]
+ #
+ # Emit a libtool wrapper script on stdout.
+ # Don't directly open a file because we may want to
+ # incorporate the script contents within a cygwin/mingw
+ # wrapper executable.  Must ONLY be called from within
+ # func_mode_link because it depends on a number of variables
+ # set therein.
+ #
+ # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
+ # variable will take.  If 'yes', then the emitted script
+ # will assume that the directory in which it is stored is
+ # the $objdir directory.  This is a cygwin/mingw-specific
+ # behavior.
+ func_emit_wrapper ()
+ {
+         func_emit_wrapper_arg1=no
+         if test -n "$1" ; then
+           func_emit_wrapper_arg1=$1
+         fi
+         # split this up so that func_emit_cwrapperexe_src
+         # can call each part independently.
+         func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"
+         func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"
+ }
+ # func_to_host_path arg
+ #
+ # Convert paths to host format when used with build tools.
+ # Intended for use with "native" mingw (where libtool itself
+ # is running under the msys shell), or in the following cross-
+ # build environments:
+ #    $build          $host
+ #    mingw (msys)    mingw  [e.g. native]
+ #    cygwin          mingw
+ #    *nix + wine     mingw
+ # where wine is equipped with the `winepath' executable.
+ # In the native mingw case, the (msys) shell automatically
+ # converts paths for any non-msys applications it launches,
+ # but that facility isn't available from inside the cwrapper.
+ # Similar accommodations are necessary for $host mingw and
+ # $build cygwin.  Calling this function does no harm for other
+ # $host/$build combinations not listed above.
+ #
+ # ARG is the path (on $build) that should be converted to
+ # the proper representation for $host. The result is stored
+ # in $func_to_host_path_result.
+ func_to_host_path ()
+ {
+   func_to_host_path_result="$1"
+   if test -n "$1" ; then
+     case $host in
+       *mingw* )
+         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
+         case $build in
+           *mingw* ) # actually, msys
+             # awkward: cmd appends spaces to result
+             lt_sed_strip_trailing_spaces="s/[ ]*\$//"
+             func_to_host_path_tmp1=`( cmd //c echo "$1" |\
+               $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
+             func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
+               $SED -e "$lt_sed_naive_backslashify"`
+             ;;
+           *cygwin* )
+             func_to_host_path_tmp1=`cygpath -w "$1"`
+             func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
+               $SED -e "$lt_sed_naive_backslashify"`
+             ;;
+           * )
+             # Unfortunately, winepath does not exit with a non-zero
+             # error code, so we are forced to check the contents of
+             # stdout. On the other hand, if the command is not
+             # found, the shell will set an exit code of 127 and print
+             # *an error message* to stdout. So we must check for both
+             # error code of zero AND non-empty stdout, which explains
+             # the odd construction:
+             func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
+             if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
+               func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
+                 $SED -e "$lt_sed_naive_backslashify"`
+             else
+               # Allow warning below.
+               func_to_host_path_result=""
+             fi
+             ;;
+         esac
+         if test -z "$func_to_host_path_result" ; then
+           func_error "Could not determine host path corresponding to"
+           func_error "  '$1'"
+           func_error "Continuing, but uninstalled executables may not work."
+           # Fallback:
+           func_to_host_path_result="$1"
+         fi
+         ;;
+     esac
+   fi
+ }
+ # end: func_to_host_path
+ # func_to_host_pathlist arg
+ #
+ # Convert pathlists to host format when used with build tools.
+ # See func_to_host_path(), above. This function supports the
+ # following $build/$host combinations (but does no harm for
+ # combinations not listed here):
+ #    $build          $host
+ #    mingw (msys)    mingw  [e.g. native]
+ #    cygwin          mingw
+ #    *nix + wine     mingw
+ #
+ # Path separators are also converted from $build format to
+ # $host format. If ARG begins or ends with a path separator
+ # character, it is preserved (but converted to $host format)
+ # on output.
+ #
+ # ARG is a pathlist (on $build) that should be converted to
+ # the proper representation on $host. The result is stored
+ # in $func_to_host_pathlist_result.
+ func_to_host_pathlist ()
+ {
+   func_to_host_pathlist_result="$1"
+   if test -n "$1" ; then
+     case $host in
+       *mingw* )
+         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
+         # Remove leading and trailing path separator characters from
+         # ARG. msys behavior is inconsistent here, cygpath turns them
+         # into '.;' and ';.', and winepath ignores them completely.
+         func_to_host_pathlist_tmp2="$1"
+         # Once set for this call, this variable should not be
+         # reassigned. It is used in tha fallback case.
+         func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\
+           $SED -e 's|^:*||' -e 's|:*$||'`
+         case $build in
+           *mingw* ) # Actually, msys.
+             # Awkward: cmd appends spaces to result.
+             lt_sed_strip_trailing_spaces="s/[ ]*\$//"
+             func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\
+               $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
+             func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
+               $SED -e "$lt_sed_naive_backslashify"`
+             ;;
+           *cygwin* )
+             func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`
+             func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
+               $SED -e "$lt_sed_naive_backslashify"`
+             ;;
+           * )
+             # unfortunately, winepath doesn't convert pathlists
+             func_to_host_pathlist_result=""
+             func_to_host_pathlist_oldIFS=$IFS
+             IFS=:
+             for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
+               IFS=$func_to_host_pathlist_oldIFS
+               if test -n "$func_to_host_pathlist_f" ; then
+                 func_to_host_path "$func_to_host_pathlist_f"
+                 if test -n "$func_to_host_path_result" ; then
+                   if test -z "$func_to_host_pathlist_result" ; then
+                     func_to_host_pathlist_result="$func_to_host_path_result"
+                   else
+                     func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"
+                   fi
+                 fi
+               fi
+               IFS=:
+             done
+             IFS=$func_to_host_pathlist_oldIFS
+             ;;
+         esac
+         if test -z "$func_to_host_pathlist_result" ; then
+           func_error "Could not determine the host path(s) corresponding to"
+           func_error "  '$1'"
+           func_error "Continuing, but uninstalled executables may not work."
+           # Fallback. This may break if $1 contains DOS-style drive
+           # specifications. The fix is not to complicate the expression
+           # below, but for the user to provide a working wine installation
+           # with winepath so that path translation in the cross-to-mingw
+           # case works properly.
+           lt_replace_pathsep_nix_to_dos="s|:|;|g"
+           func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
+             $SED -e "$lt_replace_pathsep_nix_to_dos"`
+         fi
+         # Now, add the leading and trailing path separators back
+         case "$1" in
+           :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
+             ;;
+         esac
+         case "$1" in
+           *: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"
+             ;;
+         esac
+         ;;
+     esac
+   fi
+ }
+ # end: func_to_host_pathlist
+ # func_emit_cwrapperexe_src
+ # emit the source code for a wrapper executable on stdout
+ # Must ONLY be called from within func_mode_link because
+ # it depends on a number of variable set therein.
+ func_emit_cwrapperexe_src ()
+ {
+         cat <<EOF
+ /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
+    Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
+    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* "$SHELL $output",
+    but could eventually absorb all of the scripts functionality and
+    exec $objdir/$outputname directly.
+ */
+ EOF
+             cat <<"EOF"
+ #include <stdio.h>
+ #include <stdlib.h>
+ #ifdef _MSC_VER
+ # include <direct.h>
+ # include <process.h>
+ # include <io.h>
+ # define setmode _setmode
+ #else
+ # include <unistd.h>
+ # include <stdint.h>
+ # ifdef __CYGWIN__
+ #  include <io.h>
+ #  define HAVE_SETENV
+ #  ifdef __STRICT_ANSI__
+ char *realpath (const char *, char *);
+ int putenv (char *);
+ int setenv (const char *, const char *, int);
+ #  endif
+ # endif
+ #endif
+ #include <malloc.h>
+ #include <stdarg.h>
+ #include <assert.h>
+ #include <string.h>
+ #include <ctype.h>
+ #include <errno.h>
+ #include <fcntl.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 S_IXOTH
+ # define S_IXOTH 0
+ #endif
+ #ifndef S_IXGRP
+ # define S_IXGRP 0
+ #endif
+ #ifdef _MSC_VER
+ # define S_IXUSR _S_IEXEC
+ # define stat _stat
+ # ifndef _INTPTR_T_DEFINED
+ #  define intptr_t int
+ # endif
+ #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
+ # define FOPEN_WB "wb"
+ # 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 */
+ #ifdef __CYGWIN__
+ # define FOPEN_WB "wb"
+ #endif
+ #ifndef FOPEN_WB
+ # define FOPEN_WB "w"
+ #endif
+ #ifndef _O_BINARY
+ # define _O_BINARY 0
+ #endif
+ #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
+ #define XFREE(stale) do { \
+   if (stale) { free ((void *) stale); stale = 0; } \
+ } while (0)
+ #undef LTWRAPPER_DEBUGPRINTF
+ #if defined DEBUGWRAPPER
+ # define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
+ static void
+ ltwrapper_debugprintf (const char *fmt, ...)
+ {
+     va_list args;
+     va_start (args, fmt);
+     (void) vfprintf (stderr, fmt, args);
+     va_end (args);
+ }
+ #else
+ # define LTWRAPPER_DEBUGPRINTF(args)
+ #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);
+ char *chase_symlinks (const char *pathspec);
+ int make_executable (const char *path);
+ int check_executable (const char *path);
+ char *strendzap (char *str, const char *pat);
+ void lt_fatal (const char *message, ...);
+ void lt_setenv (const char *name, const char *value);
+ char *lt_extend_str (const char *orig_value, const char *add, int to_end);
+ void lt_opt_process_env_set (const char *arg);
+ void lt_opt_process_env_prepend (const char *arg);
+ void lt_opt_process_env_append (const char *arg);
+ int lt_split_name_value (const char *arg, char** name, char** value);
+ void lt_update_exe_path (const char *name, const char *value);
+ void lt_update_lib_path (const char *name, const char *value);
+ static const char *script_text_part1 =
+ EOF
+             func_emit_wrapper_part1 yes |
+                 $SED -e 's/\([\\"]\)/\\\1/g' \
+                      -e 's/^/  "/' -e 's/$/\\n"/'
+             echo ";"
+             cat <<EOF
+ static const char *script_text_part2 =
+ EOF
+             func_emit_wrapper_part2 yes |
+                 $SED -e 's/\([\\"]\)/\\\1/g' \
+                      -e 's/^/  "/' -e 's/$/\\n"/'
+             echo ";"
+             cat <<EOF
+ const char * MAGIC_EXE = "$magic_exe";
+ const char * LIB_PATH_VARNAME = "$shlibpath_var";
+ EOF
+             if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
+               func_to_host_pathlist "$temp_rpath"
+               cat <<EOF
+ const char * LIB_PATH_VALUE   = "$func_to_host_pathlist_result";
+ EOF
+             else
+               cat <<"EOF"
+ const char * LIB_PATH_VALUE   = "";
+ EOF
+             fi
+             if test -n "$dllsearchpath"; then
+               func_to_host_pathlist "$dllsearchpath:"
+               cat <<EOF
+ const char * EXE_PATH_VARNAME = "PATH";
+ const char * EXE_PATH_VALUE   = "$func_to_host_pathlist_result";
+ EOF
+             else
+               cat <<"EOF"
+ const char * EXE_PATH_VARNAME = "";
+ const char * EXE_PATH_VALUE   = "";
+ EOF
+             fi
+             if test "$fast_install" = yes; then
+               cat <<EOF
+ const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
+ EOF
+             else
+               cat <<EOF
+ const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
+ EOF
+             fi
+             cat <<"EOF"
+ #define LTWRAPPER_OPTION_PREFIX         "--lt-"
+ #define LTWRAPPER_OPTION_PREFIX_LENGTH  5
+ static const size_t opt_prefix_len         = LTWRAPPER_OPTION_PREFIX_LENGTH;
+ static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
+ static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
+ static const size_t env_set_opt_len     = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;
+ static const char *env_set_opt          = LTWRAPPER_OPTION_PREFIX "env-set";
+   /* argument is putenv-style "foo=bar", value of foo is set to bar */
+ static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;
+ static const char *env_prepend_opt      = LTWRAPPER_OPTION_PREFIX "env-prepend";
+   /* argument is putenv-style "foo=bar", new value of foo is bar${foo} */
+ static const size_t env_append_opt_len  = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;
+ static const char *env_append_opt       = LTWRAPPER_OPTION_PREFIX "env-append";
+   /* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */
+ int
+ main (int argc, char *argv[])
+ {
+   char **newargz;
+   int  newargc;
+   char *tmp_pathspec;
+   char *actual_cwrapper_path;
+   char *actual_cwrapper_name;
+   char *target_name;
+   char *lt_argv_zero;
+   intptr_t rval = 127;
+   int i;
+   program_name = (char *) xstrdup (base_name (argv[0]));
+   LTWRAPPER_DEBUGPRINTF (("(main) argv[0]      : %s\n", argv[0]));
+   LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
+   /* very simple arg parsing; don't want to rely on getopt */
+   for (i = 1; i < argc; i++)
+     {
+       if (strcmp (argv[i], dumpscript_opt) == 0)
+         {
+ EOF
+             case "$host" in
+               *mingw* | *cygwin* )
+                 # make stdout use "unix" line endings
+                 echo "          setmode(1,_O_BINARY);"
+                 ;;
+               esac
+             cat <<"EOF"
+           printf ("%s", script_text_part1);
+           printf ("%s", script_text_part2);
+           return 0;
+         }
+     }
+   newargz = XMALLOC (char *, argc + 1);
+   tmp_pathspec = find_executable (argv[0]);
+   if (tmp_pathspec == NULL)
+     lt_fatal ("Couldn't find %s", argv[0]);
+   LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
+                           tmp_pathspec));
+   actual_cwrapper_path = chase_symlinks (tmp_pathspec);
+   LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
+                           actual_cwrapper_path));
+   XFREE (tmp_pathspec);
+   actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
+   strendzap (actual_cwrapper_path, actual_cwrapper_name);
+   /* wrapper name transforms */
+   strendzap (actual_cwrapper_name, ".exe");
+   tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
+   XFREE (actual_cwrapper_name);
+   actual_cwrapper_name = tmp_pathspec;
+   tmp_pathspec = 0;
+   /* target_name transforms -- use actual target program name; might have lt- prefix */
+   target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
+   strendzap (target_name, ".exe");
+   tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
+   XFREE (target_name);
+   target_name = tmp_pathspec;
+   tmp_pathspec = 0;
+   LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
+                           target_name));