Home | History | Annotate | Download | only in src
      1 
      2 # libtool (GNU libtool) 2.4.2
      3 # Written by Gordon Matzigkeit <gord (at] gnu.ai.mit.edu>, 1996
      4 
      5 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
      6 # 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
      7 # This is free software; see the source for copying conditions.  There is NO
      8 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
      9 
     10 # GNU Libtool is free software; you can redistribute it and/or modify
     11 # it under the terms of the GNU General Public License as published by
     12 # the Free Software Foundation; either version 2 of the License, or
     13 # (at your option) any later version.
     14 #
     15 # As a special exception to the GNU General Public License,
     16 # if you distribute this file as part of a program or library that
     17 # is built using GNU Libtool, you may include this file under the
     18 # same distribution terms that you use for the rest of that program.
     19 #
     20 # GNU Libtool is distributed in the hope that it will be useful, but
     21 # WITHOUT ANY WARRANTY; without even the implied warranty of
     22 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     23 # General Public License for more details.
     24 #
     25 # You should have received a copy of the GNU General Public License
     26 # along with GNU Libtool; see the file COPYING.  If not, a copy
     27 # can be downloaded from http://www.gnu.org/licenses/gpl.html,
     28 # or obtained by writing to the Free Software Foundation, Inc.,
     29 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
     30 
     31 # Usage: $progname [OPTION]... [MODE-ARG]...
     32 #
     33 # Provide generalized library-building support services.
     34 #
     35 #       --config             show all configuration variables
     36 #       --debug              enable verbose shell tracing
     37 #   -n, --dry-run            display commands without modifying any files
     38 #       --features           display basic configuration information and exit
     39 #       --mode=MODE          use operation mode MODE
     40 #       --preserve-dup-deps  don't remove duplicate dependency libraries
     41 #       --quiet, --silent    don't print informational messages
     42 #       --no-quiet, --no-silent
     43 #                            print informational messages (default)
     44 #       --no-warn            don't display warning messages
     45 #       --tag=TAG            use configuration variables from tag TAG
     46 #   -v, --verbose            print more informational messages than default
     47 #       --no-verbose         don't print the extra informational messages
     48 #       --version            print version information
     49 #   -h, --help, --help-all   print short, long, or detailed help message
     50 #
     51 # MODE must be one of the following:
     52 #
     53 #         clean              remove files from the build directory
     54 #         compile            compile a source file into a libtool object
     55 #         execute            automatically set library path, then run a program
     56 #         finish             complete the installation of libtool libraries
     57 #         install            install libraries or executables
     58 #         link               create a library or an executable
     59 #         uninstall          remove libraries from an installed directory
     60 #
     61 # MODE-ARGS vary depending on the MODE.  When passed as first option,
     62 # `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
     63 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
     64 #
     65 # When reporting a bug, please describe a test case to reproduce it and
     66 # include the following information:
     67 #
     68 #         host-triplet:	$host
     69 #         shell:		$SHELL
     70 #         compiler:		$LTCC
     71 #         compiler flags:		$LTCFLAGS
     72 #         linker:		$LD (gnu? $with_gnu_ld)
     73 #         $progname:	(GNU libtool) 2.4.2
     74 #         automake:	$automake_version
     75 #         autoconf:	$autoconf_version
     76 #
     77 # Report bugs to <bug-libtool (at] gnu.org>.
     78 # GNU libtool home page: <http://www.gnu.org/software/libtool/>.
     79 # General help using GNU software: <http://www.gnu.org/gethelp/>.
     80 
     81 PROGRAM=libtool
     82 PACKAGE=libtool
     83 VERSION=2.4.2
     84 TIMESTAMP=""
     85 package_revision=1.3337
     86 
     87 # Be Bourne compatible
     88 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
     89   emulate sh
     90   NULLCMD=:
     91   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
     92   # is contrary to our usage.  Disable this feature.
     93   alias -g '${1+"$@"}'='"$@"'
     94   setopt NO_GLOB_SUBST
     95 else
     96   case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
     97 fi
     98 BIN_SH=xpg4; export BIN_SH # for Tru64
     99 DUALCASE=1; export DUALCASE # for MKS sh
    100 
    101 # A function that is used when there is no print builtin or printf.
    102 func_fallback_echo ()
    103 {
    104   eval 'cat <<_LTECHO_EOF
    105 $1
    106 _LTECHO_EOF'
    107 }
    108 
    109 # NLS nuisances: We save the old values to restore during execute mode.
    110 lt_user_locale=
    111 lt_safe_locale=
    112 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
    113 do
    114   eval "if test \"\${$lt_var+set}\" = set; then
    115           save_$lt_var=\$$lt_var
    116           $lt_var=C
    117 	  export $lt_var
    118 	  lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
    119 	  lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
    120 	fi"
    121 done
    122 LC_ALL=C
    123 LANGUAGE=C
    124 export LANGUAGE LC_ALL
    125 
    126 $lt_unset CDPATH
    127 
    128 
    129 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
    130 # is ksh but when the shell is invoked as "sh" and the current value of
    131 # the _XPG environment variable is not equal to 1 (one), the special
    132 # positional parameter $0, within a function call, is the name of the
    133 # function.
    134 progpath="$0"
    135 
    136 
    137 
    138 : ${CP="cp -f"}
    139 test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
    140 : ${MAKE="make"}
    141 : ${MKDIR="mkdir"}
    142 : ${MV="mv -f"}
    143 : ${RM="rm -f"}
    144 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
    145 : ${Xsed="$SED -e 1s/^X//"}
    146 
    147 # Global variables:
    148 EXIT_SUCCESS=0
    149 EXIT_FAILURE=1
    150 EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
    151 EXIT_SKIP=77	  # $? = 77 is used to indicate a skipped test to automake.
    152 
    153 exit_status=$EXIT_SUCCESS
    154 
    155 # Make sure IFS has a sensible default
    156 lt_nl='
    157 '
    158 IFS=" 	$lt_nl"
    159 
    160 dirname="s,/[^/]*$,,"
    161 basename="s,^.*/,,"
    162 
    163 # func_dirname file append nondir_replacement
    164 # Compute the dirname of FILE.  If nonempty, add APPEND to the result,
    165 # otherwise set result to NONDIR_REPLACEMENT.
    166 func_dirname ()
    167 {
    168     func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
    169     if test "X$func_dirname_result" = "X${1}"; then
    170       func_dirname_result="${3}"
    171     else
    172       func_dirname_result="$func_dirname_result${2}"
    173     fi
    174 } # func_dirname may be replaced by extended shell implementation
    175 
    176 
    177 # func_basename file
    178 func_basename ()
    179 {
    180     func_basename_result=`$ECHO "${1}" | $SED "$basename"`
    181 } # func_basename may be replaced by extended shell implementation
    182 
    183 
    184 # func_dirname_and_basename file append nondir_replacement
    185 # perform func_basename and func_dirname in a single function
    186 # call:
    187 #   dirname:  Compute the dirname of FILE.  If nonempty,
    188 #             add APPEND to the result, otherwise set result
    189 #             to NONDIR_REPLACEMENT.
    190 #             value returned in "$func_dirname_result"
    191 #   basename: Compute filename of FILE.
    192 #             value retuned in "$func_basename_result"
    193 # Implementation must be kept synchronized with func_dirname
    194 # and func_basename. For efficiency, we do not delegate to
    195 # those functions but instead duplicate the functionality here.
    196 func_dirname_and_basename ()
    197 {
    198     # Extract subdirectory from the argument.
    199     func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
    200     if test "X$func_dirname_result" = "X${1}"; then
    201       func_dirname_result="${3}"
    202     else
    203       func_dirname_result="$func_dirname_result${2}"
    204     fi
    205     func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
    206 } # func_dirname_and_basename may be replaced by extended shell implementation
    207 
    208 
    209 # func_stripname prefix suffix name
    210 # strip PREFIX and SUFFIX off of NAME.
    211 # PREFIX and SUFFIX must not contain globbing or regex special
    212 # characters, hashes, percent signs, but SUFFIX may contain a leading
    213 # dot (in which case that matches only a dot).
    214 # func_strip_suffix prefix name
    215 func_stripname ()
    216 {
    217     case ${2} in
    218       .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
    219       *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
    220     esac
    221 } # func_stripname may be replaced by extended shell implementation
    222 
    223 
    224 # These SED scripts presuppose an absolute path with a trailing slash.
    225 pathcar='s,^/\([^/]*\).*$,\1,'
    226 pathcdr='s,^/[^/]*,,'
    227 removedotparts=':dotsl
    228 		s@/\./@/@g
    229 		t dotsl
    230 		s,/\.$,/,'
    231 collapseslashes='s@/\{1,\}@/@g'
    232 finalslash='s,/*$,/,'
    233 
    234 # func_normal_abspath PATH
    235 # Remove doubled-up and trailing slashes, "." path components,
    236 # and cancel out any ".." path components in PATH after making
    237 # it an absolute path.
    238 #             value returned in "$func_normal_abspath_result"
    239 func_normal_abspath ()
    240 {
    241   # Start from root dir and reassemble the path.
    242   func_normal_abspath_result=
    243   func_normal_abspath_tpath=$1
    244   func_normal_abspath_altnamespace=
    245   case $func_normal_abspath_tpath in
    246     "")
    247       # Empty path, that just means $cwd.
    248       func_stripname '' '/' "`pwd`"
    249       func_normal_abspath_result=$func_stripname_result
    250       return
    251     ;;
    252     # The next three entries are used to spot a run of precisely
    253     # two leading slashes without using negated character classes;
    254     # we take advantage of case's first-match behaviour.
    255     ///*)
    256       # Unusual form of absolute path, do nothing.
    257     ;;
    258     //*)
    259       # Not necessarily an ordinary path; POSIX reserves leading '//'
    260       # and for example Cygwin uses it to access remote file shares
    261       # over CIFS/SMB, so we conserve a leading double slash if found.
    262       func_normal_abspath_altnamespace=/
    263     ;;
    264     /*)
    265       # Absolute path, do nothing.
    266     ;;
    267     *)
    268       # Relative path, prepend $cwd.
    269       func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
    270     ;;
    271   esac
    272   # Cancel out all the simple stuff to save iterations.  We also want
    273   # the path to end with a slash for ease of parsing, so make sure
    274   # there is one (and only one) here.
    275   func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
    276         -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
    277   while :; do
    278     # Processed it all yet?
    279     if test "$func_normal_abspath_tpath" = / ; then
    280       # If we ascended to the root using ".." the result may be empty now.
    281       if test -z "$func_normal_abspath_result" ; then
    282         func_normal_abspath_result=/
    283       fi
    284       break
    285     fi
    286     func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
    287         -e "$pathcar"`
    288     func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
    289         -e "$pathcdr"`
    290     # Figure out what to do with it
    291     case $func_normal_abspath_tcomponent in
    292       "")
    293         # Trailing empty path component, ignore it.
    294       ;;
    295       ..)
    296         # Parent dir; strip last assembled component from result.
    297         func_dirname "$func_normal_abspath_result"
    298         func_normal_abspath_result=$func_dirname_result
    299       ;;
    300       *)
    301         # Actual path component, append it.
    302         func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
    303       ;;
    304     esac
    305   done
    306   # Restore leading double-slash if one was found on entry.
    307   func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
    308 }
    309 
    310 # func_relative_path SRCDIR DSTDIR
    311 # generates a relative path from SRCDIR to DSTDIR, with a trailing
    312 # slash if non-empty, suitable for immediately appending a filename
    313 # without needing to append a separator.
    314 #             value returned in "$func_relative_path_result"
    315 func_relative_path ()
    316 {
    317   func_relative_path_result=
    318   func_normal_abspath "$1"
    319   func_relative_path_tlibdir=$func_normal_abspath_result
    320   func_normal_abspath "$2"
    321   func_relative_path_tbindir=$func_normal_abspath_result
    322 
    323   # Ascend the tree starting from libdir
    324   while :; do
    325     # check if we have found a prefix of bindir
    326     case $func_relative_path_tbindir in
    327       $func_relative_path_tlibdir)
    328         # found an exact match
    329         func_relative_path_tcancelled=
    330         break
    331         ;;
    332       $func_relative_path_tlibdir*)
    333         # found a matching prefix
    334         func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
    335         func_relative_path_tcancelled=$func_stripname_result
    336         if test -z "$func_relative_path_result"; then
    337           func_relative_path_result=.
    338         fi
    339         break
    340         ;;
    341       *)
    342         func_dirname $func_relative_path_tlibdir
    343         func_relative_path_tlibdir=${func_dirname_result}
    344         if test "x$func_relative_path_tlibdir" = x ; then
    345           # Have to descend all the way to the root!
    346           func_relative_path_result=../$func_relative_path_result
    347           func_relative_path_tcancelled=$func_relative_path_tbindir
    348           break
    349         fi
    350         func_relative_path_result=../$func_relative_path_result
    351         ;;
    352     esac
    353   done
    354 
    355   # Now calculate path; take care to avoid doubling-up slashes.
    356   func_stripname '' '/' "$func_relative_path_result"
    357   func_relative_path_result=$func_stripname_result
    358   func_stripname '/' '/' "$func_relative_path_tcancelled"
    359   if test "x$func_stripname_result" != x ; then
    360     func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
    361   fi
    362 
    363   # Normalisation. If bindir is libdir, return empty string,
    364   # else relative path ending with a slash; either way, target
    365   # file name can be directly appended.
    366   if test ! -z "$func_relative_path_result"; then
    367     func_stripname './' '' "$func_relative_path_result/"
    368     func_relative_path_result=$func_stripname_result
    369   fi
    370 }
    371 
    372 # The name of this program:
    373 func_dirname_and_basename "$progpath"
    374 progname=$func_basename_result
    375 
    376 # Make sure we have an absolute path for reexecution:
    377 case $progpath in
    378   [\\/]*|[A-Za-z]:\\*) ;;
    379   *[\\/]*)
    380      progdir=$func_dirname_result
    381      progdir=`cd "$progdir" && pwd`
    382      progpath="$progdir/$progname"
    383      ;;
    384   *)
    385      save_IFS="$IFS"
    386      IFS=${PATH_SEPARATOR-:}
    387      for progdir in $PATH; do
    388        IFS="$save_IFS"
    389        test -x "$progdir/$progname" && break
    390      done
    391      IFS="$save_IFS"
    392      test -n "$progdir" || progdir=`pwd`
    393      progpath="$progdir/$progname"
    394      ;;
    395 esac
    396 
    397 # Sed substitution that helps us do robust quoting.  It backslashifies
    398 # metacharacters that are still active within double-quoted strings.
    399 Xsed="${SED}"' -e 1s/^X//'
    400 sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
    401 
    402 # Same as above, but do not quote variable references.
    403 double_quote_subst='s/\(["`\\]\)/\\\1/g'
    404 
    405 # Sed substitution that turns a string into a regex matching for the
    406 # string literally.
    407 sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
    408 
    409 # Sed substitution that converts a w32 file name or path
    410 # which contains forward slashes, into one that contains
    411 # (escaped) backslashes.  A very naive implementation.
    412 lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
    413 
    414 # Re-`\' parameter expansions in output of double_quote_subst that were
    415 # `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
    416 # in input to double_quote_subst, that '$' was protected from expansion.
    417 # Since each input `\' is now two `\'s, look for any number of runs of
    418 # four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
    419 bs='\\'
    420 bs2='\\\\'
    421 bs4='\\\\\\\\'
    422 dollar='\$'
    423 sed_double_backslash="\
    424   s/$bs4/&\\
    425 /g
    426   s/^$bs2$dollar/$bs&/
    427   s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
    428   s/\n//g"
    429 
    430 # Standard options:
    431 opt_dry_run=false
    432 opt_help=false
    433 opt_quiet=false
    434 opt_verbose=false
    435 opt_warning=:
    436 
    437 # func_echo arg...
    438 # Echo program name prefixed message, along with the current mode
    439 # name if it has been set yet.
    440 func_echo ()
    441 {
    442     $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
    443 }
    444 
    445 # func_verbose arg...
    446 # Echo program name prefixed message in verbose mode only.
    447 func_verbose ()
    448 {
    449     $opt_verbose && func_echo ${1+"$@"}
    450 
    451     # A bug in bash halts the script if the last line of a function
    452     # fails when set -e is in force, so we need another command to
    453     # work around that:
    454     :
    455 }
    456 
    457 # func_echo_all arg...
    458 # Invoke $ECHO with all args, space-separated.
    459 func_echo_all ()
    460 {
    461     $ECHO "$*"
    462 }
    463 
    464 # func_error arg...
    465 # Echo program name prefixed message to standard error.
    466 func_error ()
    467 {
    468     $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
    469 }
    470 
    471 # func_warning arg...
    472 # Echo program name prefixed warning message to standard error.
    473 func_warning ()
    474 {
    475     $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
    476 
    477     # bash bug again:
    478     :
    479 }
    480 
    481 # func_fatal_error arg...
    482 # Echo program name prefixed message to standard error, and exit.
    483 func_fatal_error ()
    484 {
    485     func_error ${1+"$@"}
    486     exit $EXIT_FAILURE
    487 }
    488 
    489 # func_fatal_help arg...
    490 # Echo program name prefixed message to standard error, followed by
    491 # a help hint, and exit.
    492 func_fatal_help ()
    493 {
    494     func_error ${1+"$@"}
    495     func_fatal_error "$help"
    496 }
    497 help="Try \`$progname --help' for more information."  ## default
    498 
    499 
    500 # func_grep expression filename
    501 # Check whether EXPRESSION matches any line of FILENAME, without output.
    502 func_grep ()
    503 {
    504     $GREP "$1" "$2" >/dev/null 2>&1
    505 }
    506 
    507 
    508 # func_mkdir_p directory-path
    509 # Make sure the entire path to DIRECTORY-PATH is available.
    510 func_mkdir_p ()
    511 {
    512     my_directory_path="$1"
    513     my_dir_list=
    514 
    515     if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
    516 
    517       # Protect directory names starting with `-'
    518       case $my_directory_path in
    519         -*) my_directory_path="./$my_directory_path" ;;
    520       esac
    521 
    522       # While some portion of DIR does not yet exist...
    523       while test ! -d "$my_directory_path"; do
    524         # ...make a list in topmost first order.  Use a colon delimited
    525 	# list incase some portion of path contains whitespace.
    526         my_dir_list="$my_directory_path:$my_dir_list"
    527 
    528         # If the last portion added has no slash in it, the list is done
    529         case $my_directory_path in */*) ;; *) break ;; esac
    530 
    531         # ...otherwise throw away the child directory and loop
    532         my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
    533       done
    534       my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
    535 
    536       save_mkdir_p_IFS="$IFS"; IFS=':'
    537       for my_dir in $my_dir_list; do
    538 	IFS="$save_mkdir_p_IFS"
    539         # mkdir can fail with a `File exist' error if two processes
    540         # try to create one of the directories concurrently.  Don't
    541         # stop in that case!
    542         $MKDIR "$my_dir" 2>/dev/null || :
    543       done
    544       IFS="$save_mkdir_p_IFS"
    545 
    546       # Bail out if we (or some other process) failed to create a directory.
    547       test -d "$my_directory_path" || \
    548         func_fatal_error "Failed to create \`$1'"
    549     fi
    550 }
    551 
    552 
    553 # func_mktempdir [string]
    554 # Make a temporary directory that won't clash with other running
    555 # libtool processes, and avoids race conditions if possible.  If
    556 # given, STRING is the basename for that directory.
    557 func_mktempdir ()
    558 {
    559     my_template="${TMPDIR-/tmp}/${1-$progname}"
    560 
    561     if test "$opt_dry_run" = ":"; then
    562       # Return a directory name, but don't create it in dry-run mode
    563       my_tmpdir="${my_template}-$$"
    564     else
    565 
    566       # If mktemp works, use that first and foremost
    567       my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
    568 
    569       if test ! -d "$my_tmpdir"; then
    570         # Failing that, at least try and use $RANDOM to avoid a race
    571         my_tmpdir="${my_template}-${RANDOM-0}$$"
    572 
    573         save_mktempdir_umask=`umask`
    574         umask 0077
    575         $MKDIR "$my_tmpdir"
    576         umask $save_mktempdir_umask
    577       fi
    578 
    579       # If we're not in dry-run mode, bomb out on failure
    580       test -d "$my_tmpdir" || \
    581         func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
    582     fi
    583 
    584     $ECHO "$my_tmpdir"
    585 }
    586 
    587 
    588 # func_quote_for_eval arg
    589 # Aesthetically quote ARG to be evaled later.
    590 # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
    591 # is double-quoted, suitable for a subsequent eval, whereas
    592 # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
    593 # which are still active within double quotes backslashified.
    594 func_quote_for_eval ()
    595 {
    596     case $1 in
    597       *[\\\`\"\$]*)
    598 	func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
    599       *)
    600         func_quote_for_eval_unquoted_result="$1" ;;
    601     esac
    602 
    603     case $func_quote_for_eval_unquoted_result in
    604       # Double-quote args containing shell metacharacters to delay
    605       # word splitting, command substitution and and variable
    606       # expansion for a subsequent eval.
    607       # Many Bourne shells cannot handle close brackets correctly
    608       # in scan sets, so we specify it separately.
    609       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
    610         func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
    611         ;;
    612       *)
    613         func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
    614     esac
    615 }
    616 
    617 
    618 # func_quote_for_expand arg
    619 # Aesthetically quote ARG to be evaled later; same as above,
    620 # but do not quote variable references.
    621 func_quote_for_expand ()
    622 {
    623     case $1 in
    624       *[\\\`\"]*)
    625 	my_arg=`$ECHO "$1" | $SED \
    626 	    -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
    627       *)
    628         my_arg="$1" ;;
    629     esac
    630 
    631     case $my_arg in
    632       # Double-quote args containing shell metacharacters to delay
    633       # word splitting and command substitution for a subsequent eval.
    634       # Many Bourne shells cannot handle close brackets correctly
    635       # in scan sets, so we specify it separately.
    636       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
    637         my_arg="\"$my_arg\""
    638         ;;
    639     esac
    640 
    641     func_quote_for_expand_result="$my_arg"
    642 }
    643 
    644 
    645 # func_show_eval cmd [fail_exp]
    646 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
    647 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
    648 # is given, then evaluate it.
    649 func_show_eval ()
    650 {
    651     my_cmd="$1"
    652     my_fail_exp="${2-:}"
    653 
    654     ${opt_silent-false} || {
    655       func_quote_for_expand "$my_cmd"
    656       eval "func_echo $func_quote_for_expand_result"
    657     }
    658 
    659     if ${opt_dry_run-false}; then :; else
    660       eval "$my_cmd"
    661       my_status=$?
    662       if test "$my_status" -eq 0; then :; else
    663 	eval "(exit $my_status); $my_fail_exp"
    664       fi
    665     fi
    666 }
    667 
    668 
    669 # func_show_eval_locale cmd [fail_exp]
    670 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
    671 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
    672 # is given, then evaluate it.  Use the saved locale for evaluation.
    673 func_show_eval_locale ()
    674 {
    675     my_cmd="$1"
    676     my_fail_exp="${2-:}"
    677 
    678     ${opt_silent-false} || {
    679       func_quote_for_expand "$my_cmd"
    680       eval "func_echo $func_quote_for_expand_result"
    681     }
    682 
    683     if ${opt_dry_run-false}; then :; else
    684       eval "$lt_user_locale
    685 	    $my_cmd"
    686       my_status=$?
    687       eval "$lt_safe_locale"
    688       if test "$my_status" -eq 0; then :; else
    689 	eval "(exit $my_status); $my_fail_exp"
    690       fi
    691     fi
    692 }
    693 
    694 # func_tr_sh
    695 # Turn $1 into a string suitable for a shell variable name.
    696 # Result is stored in $func_tr_sh_result.  All characters
    697 # not in the set a-zA-Z0-9_ are replaced with '_'. Further,
    698 # if $1 begins with a digit, a '_' is prepended as well.
    699 func_tr_sh ()
    700 {
    701   case $1 in
    702   [0-9]* | *[!a-zA-Z0-9_]*)
    703     func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
    704     ;;
    705   * )
    706     func_tr_sh_result=$1
    707     ;;
    708   esac
    709 }
    710 
    711 
    712 # func_version
    713 # Echo version message to standard output and exit.
    714 func_version ()
    715 {
    716     $opt_debug
    717 
    718     $SED -n '/(C)/!b go
    719 	:more
    720 	/\./!{
    721 	  N
    722 	  s/\n# / /
    723 	  b more
    724 	}
    725 	:go
    726 	/^# '$PROGRAM' (GNU /,/# warranty; / {
    727         s/^# //
    728 	s/^# *$//
    729         s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
    730         p
    731      }' < "$progpath"
    732      exit $?
    733 }
    734 
    735 # func_usage
    736 # Echo short help message to standard output and exit.
    737 func_usage ()
    738 {
    739     $opt_debug
    740 
    741     $SED -n '/^# Usage:/,/^#  *.*--help/ {
    742         s/^# //
    743 	s/^# *$//
    744 	s/\$progname/'$progname'/
    745 	p
    746     }' < "$progpath"
    747     echo
    748     $ECHO "run \`$progname --help | more' for full usage"
    749     exit $?
    750 }
    751 
    752 # func_help [NOEXIT]
    753 # Echo long help message to standard output and exit,
    754 # unless 'noexit' is passed as argument.
    755 func_help ()
    756 {
    757     $opt_debug
    758 
    759     $SED -n '/^# Usage:/,/# Report bugs to/ {
    760 	:print
    761         s/^# //
    762 	s/^# *$//
    763 	s*\$progname*'$progname'*
    764 	s*\$host*'"$host"'*
    765 	s*\$SHELL*'"$SHELL"'*
    766 	s*\$LTCC*'"$LTCC"'*
    767 	s*\$LTCFLAGS*'"$LTCFLAGS"'*
    768 	s*\$LD*'"$LD"'*
    769 	s/\$with_gnu_ld/'"$with_gnu_ld"'/
    770 	s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
    771 	s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
    772 	p
    773 	d
    774      }
    775      /^# .* home page:/b print
    776      /^# General help using/b print
    777      ' < "$progpath"
    778     ret=$?
    779     if test -z "$1"; then
    780       exit $ret
    781     fi
    782 }
    783 
    784 # func_missing_arg argname
    785 # Echo program name prefixed message to standard error and set global
    786 # exit_cmd.
    787 func_missing_arg ()
    788 {
    789     $opt_debug
    790 
    791     func_error "missing argument for $1."
    792     exit_cmd=exit
    793 }
    794 
    795 
    796 # func_split_short_opt shortopt
    797 # Set func_split_short_opt_name and func_split_short_opt_arg shell
    798 # variables after splitting SHORTOPT after the 2nd character.
    799 func_split_short_opt ()
    800 {
    801     my_sed_short_opt='1s/^\(..\).*$/\1/;q'
    802     my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
    803 
    804     func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
    805     func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
    806 } # func_split_short_opt may be replaced by extended shell implementation
    807 
    808 
    809 # func_split_long_opt longopt
    810 # Set func_split_long_opt_name and func_split_long_opt_arg shell
    811 # variables after splitting LONGOPT at the `=' sign.
    812 func_split_long_opt ()
    813 {
    814     my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
    815     my_sed_long_arg='1s/^--[^=]*=//'
    816 
    817     func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
    818     func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
    819 } # func_split_long_opt may be replaced by extended shell implementation
    820 
    821 exit_cmd=:
    822 
    823 
    824 
    825 
    826 
    827 magic="%%%MAGIC variable%%%"
    828 magic_exe="%%%MAGIC EXE variable%%%"
    829 
    830 # Global variables.
    831 nonopt=
    832 preserve_args=
    833 lo2o="s/\\.lo\$/.${objext}/"
    834 o2lo="s/\\.${objext}\$/.lo/"
    835 extracted_archives=
    836 extracted_serial=0
    837 
    838 # If this variable is set in any of the actions, the command in it
    839 # will be execed at the end.  This prevents here-documents from being
    840 # left over by shells.
    841 exec_cmd=
    842 
    843 # func_append var value
    844 # Append VALUE to the end of shell variable VAR.
    845 func_append ()
    846 {
    847     eval "${1}=\$${1}\${2}"
    848 } # func_append may be replaced by extended shell implementation
    849 
    850 # func_append_quoted var value
    851 # Quote VALUE and append to the end of shell variable VAR, separated
    852 # by a space.
    853 func_append_quoted ()
    854 {
    855     func_quote_for_eval "${2}"
    856     eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
    857 } # func_append_quoted may be replaced by extended shell implementation
    858 
    859 
    860 # func_arith arithmetic-term...
    861 func_arith ()
    862 {
    863     func_arith_result=`expr "${@}"`
    864 } # func_arith may be replaced by extended shell implementation
    865 
    866 
    867 # func_len string
    868 # STRING may not start with a hyphen.
    869 func_len ()
    870 {
    871     func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
    872 } # func_len may be replaced by extended shell implementation
    873 
    874 
    875 # func_lo2o object
    876 func_lo2o ()
    877 {
    878     func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
    879 } # func_lo2o may be replaced by extended shell implementation
    880 
    881 
    882 # func_xform libobj-or-source
    883 func_xform ()
    884 {
    885     func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
    886 } # func_xform may be replaced by extended shell implementation
    887 
    888 
    889 # func_fatal_configuration arg...
    890 # Echo program name prefixed message to standard error, followed by
    891 # a configuration failure hint, and exit.
    892 func_fatal_configuration ()
    893 {
    894     func_error ${1+"$@"}
    895     func_error "See the $PACKAGE documentation for more information."
    896     func_fatal_error "Fatal configuration error."
    897 }
    898 
    899 
    900 # func_config
    901 # Display the configuration for all the tags in this script.
    902 func_config ()
    903 {
    904     re_begincf='^# ### BEGIN LIBTOOL'
    905     re_endcf='^# ### END LIBTOOL'
    906 
    907     # Default configuration.
    908     $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
    909 
    910     # Now print the configurations for the tags.
    911     for tagname in $taglist; do
    912       $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
    913     done
    914 
    915     exit $?
    916 }
    917 
    918 # func_features
    919 # Display the features supported by this script.
    920 func_features ()
    921 {
    922     echo "host: $host"
    923     if test "$build_libtool_libs" = yes; then
    924       echo "enable shared libraries"
    925     else
    926       echo "disable shared libraries"
    927     fi
    928     if test "$build_old_libs" = yes; then
    929       echo "enable static libraries"
    930     else
    931       echo "disable static libraries"
    932     fi
    933 
    934     exit $?
    935 }
    936 
    937 # func_enable_tag tagname
    938 # Verify that TAGNAME is valid, and either flag an error and exit, or
    939 # enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
    940 # variable here.
    941 func_enable_tag ()
    942 {
    943   # Global variable:
    944   tagname="$1"
    945 
    946   re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
    947   re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
    948   sed_extractcf="/$re_begincf/,/$re_endcf/p"
    949 
    950   # Validate tagname.
    951   case $tagname in
    952     *[!-_A-Za-z0-9,/]*)
    953       func_fatal_error "invalid tag name: $tagname"
    954       ;;
    955   esac
    956 
    957   # Don't test for the "default" C tag, as we know it's
    958   # there but not specially marked.
    959   case $tagname in
    960     CC) ;;
    961     *)
    962       if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
    963 	taglist="$taglist $tagname"
    964 
    965 	# Evaluate the configuration.  Be careful to quote the path
    966 	# and the sed script, to avoid splitting on whitespace, but
    967 	# also don't use non-portable quotes within backquotes within
    968 	# quotes we have to do it in 2 steps:
    969 	extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
    970 	eval "$extractedcf"
    971       else
    972 	func_error "ignoring unknown tag $tagname"
    973       fi
    974       ;;
    975   esac
    976 }
    977 
    978 # func_check_version_match
    979 # Ensure that we are using m4 macros, and libtool script from the same
    980 # release of libtool.
    981 func_check_version_match ()
    982 {
    983   if test "$package_revision" != "$macro_revision"; then
    984     if test "$VERSION" != "$macro_version"; then
    985       if test -z "$macro_version"; then
    986         cat >&2 <<_LT_EOF
    987 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
    988 $progname: definition of this LT_INIT comes from an older release.
    989 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
    990 $progname: and run autoconf again.
    991 _LT_EOF
    992       else
    993         cat >&2 <<_LT_EOF
    994 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
    995 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
    996 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
    997 $progname: and run autoconf again.
    998 _LT_EOF
    999       fi
   1000     else
   1001       cat >&2 <<_LT_EOF
   1002 $progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
   1003 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
   1004 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
   1005 $progname: of $PACKAGE $VERSION and run autoconf again.
   1006 _LT_EOF
   1007     fi
   1008 
   1009     exit $EXIT_MISMATCH
   1010   fi
   1011 }
   1012 
   1013 
   1014 # Shorthand for --mode=foo, only valid as the first argument
   1015 case $1 in
   1016 clean|clea|cle|cl)
   1017   shift; set dummy --mode clean ${1+"$@"}; shift
   1018   ;;
   1019 compile|compil|compi|comp|com|co|c)
   1020   shift; set dummy --mode compile ${1+"$@"}; shift
   1021   ;;
   1022 execute|execut|execu|exec|exe|ex|e)
   1023   shift; set dummy --mode execute ${1+"$@"}; shift
   1024   ;;
   1025 finish|finis|fini|fin|fi|f)
   1026   shift; set dummy --mode finish ${1+"$@"}; shift
   1027   ;;
   1028 install|instal|insta|inst|ins|in|i)
   1029   shift; set dummy --mode install ${1+"$@"}; shift
   1030   ;;
   1031 link|lin|li|l)
   1032   shift; set dummy --mode link ${1+"$@"}; shift
   1033   ;;
   1034 uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
   1035   shift; set dummy --mode uninstall ${1+"$@"}; shift
   1036   ;;
   1037 esac
   1038 
   1039 
   1040 
   1041 # Option defaults:
   1042 opt_debug=:
   1043 opt_dry_run=false
   1044 opt_config=false
   1045 opt_preserve_dup_deps=false
   1046 opt_features=false
   1047 opt_finish=false
   1048 opt_help=false
   1049 opt_help_all=false
   1050 opt_silent=:
   1051 opt_warning=:
   1052 opt_verbose=:
   1053 opt_silent=false
   1054 opt_verbose=false
   1055 
   1056 
   1057 # Parse options once, thoroughly.  This comes as soon as possible in the
   1058 # script to make things like `--version' happen as quickly as we can.
   1059 {
   1060   # this just eases exit handling
   1061   while test $# -gt 0; do
   1062     opt="$1"
   1063     shift
   1064     case $opt in
   1065       --debug|-x)	opt_debug='set -x'
   1066 			func_echo "enabling shell trace mode"
   1067 			$opt_debug
   1068 			;;
   1069       --dry-run|--dryrun|-n)
   1070 			opt_dry_run=:
   1071 			;;
   1072       --config)
   1073 			opt_config=:
   1074 func_config
   1075 			;;
   1076       --dlopen|-dlopen)
   1077 			optarg="$1"
   1078 			opt_dlopen="${opt_dlopen+$opt_dlopen
   1079 }$optarg"
   1080 			shift
   1081 			;;
   1082       --preserve-dup-deps)
   1083 			opt_preserve_dup_deps=:
   1084 			;;
   1085       --features)
   1086 			opt_features=:
   1087 func_features
   1088 			;;
   1089       --finish)
   1090 			opt_finish=:
   1091 set dummy --mode finish ${1+"$@"}; shift
   1092 			;;
   1093       --help)
   1094 			opt_help=:
   1095 			;;
   1096       --help-all)
   1097 			opt_help_all=:
   1098 opt_help=': help-all'
   1099 			;;
   1100       --mode)
   1101 			test $# = 0 && func_missing_arg $opt && break
   1102 			optarg="$1"
   1103 			opt_mode="$optarg"
   1104 case $optarg in
   1105   # Valid mode arguments:
   1106   clean|compile|execute|finish|install|link|relink|uninstall) ;;
   1107 
   1108   # Catch anything else as an error
   1109   *) func_error "invalid argument for $opt"
   1110      exit_cmd=exit
   1111      break
   1112      ;;
   1113 esac
   1114 			shift
   1115 			;;
   1116       --no-silent|--no-quiet)
   1117 			opt_silent=false
   1118 func_append preserve_args " $opt"
   1119 			;;
   1120       --no-warning|--no-warn)
   1121 			opt_warning=false
   1122 func_append preserve_args " $opt"
   1123 			;;
   1124       --no-verbose)
   1125 			opt_verbose=false
   1126 func_append preserve_args " $opt"
   1127 			;;
   1128       --silent|--quiet)
   1129 			opt_silent=:
   1130 func_append preserve_args " $opt"
   1131         opt_verbose=false
   1132 			;;
   1133       --verbose|-v)
   1134 			opt_verbose=:
   1135 func_append preserve_args " $opt"
   1136 opt_silent=false
   1137 			;;
   1138       --tag)
   1139 			test $# = 0 && func_missing_arg $opt && break
   1140 			optarg="$1"
   1141 			opt_tag="$optarg"
   1142 func_append preserve_args " $opt $optarg"
   1143 func_enable_tag "$optarg"
   1144 			shift
   1145 			;;
   1146 
   1147       -\?|-h)		func_usage				;;
   1148       --help)		func_help				;;
   1149       --version)	func_version				;;
   1150 
   1151       # Separate optargs to long options:
   1152       --*=*)
   1153 			func_split_long_opt "$opt"
   1154 			set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
   1155 			shift
   1156 			;;
   1157 
   1158       # Separate non-argument short options:
   1159       -\?*|-h*|-n*|-v*)
   1160 			func_split_short_opt "$opt"
   1161 			set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
   1162 			shift
   1163 			;;
   1164 
   1165       --)		break					;;
   1166       -*)		func_fatal_help "unrecognized option \`$opt'" ;;
   1167       *)		set dummy "$opt" ${1+"$@"};	shift; break  ;;
   1168     esac
   1169   done
   1170 
   1171   # Validate options:
   1172 
   1173   # save first non-option argument
   1174   if test "$#" -gt 0; then
   1175     nonopt="$opt"
   1176     shift
   1177   fi
   1178 
   1179   # preserve --debug
   1180   test "$opt_debug" = : || func_append preserve_args " --debug"
   1181 
   1182   case $host in
   1183     *cygwin* | *mingw* | *pw32* | *cegcc*)
   1184       # don't eliminate duplications in $postdeps and $predeps
   1185       opt_duplicate_compiler_generated_deps=:
   1186       ;;
   1187     *)
   1188       opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
   1189       ;;
   1190   esac
   1191 
   1192   $opt_help || {
   1193     # Sanity checks first:
   1194     func_check_version_match
   1195 
   1196     if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
   1197       func_fatal_configuration "not configured to build any kind of library"
   1198     fi
   1199 
   1200     # Darwin sucks
   1201     eval std_shrext=\"$shrext_cmds\"
   1202 
   1203     # Only execute mode is allowed to have -dlopen flags.
   1204     if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
   1205       func_error "unrecognized option \`-dlopen'"
   1206       $ECHO "$help" 1>&2
   1207       exit $EXIT_FAILURE
   1208     fi
   1209 
   1210     # Change the help message to a mode-specific one.
   1211     generic_help="$help"
   1212     help="Try \`$progname --help --mode=$opt_mode' for more information."
   1213   }
   1214 
   1215 
   1216   # Bail if the options were screwed
   1217   $exit_cmd $EXIT_FAILURE
   1218 }
   1219 
   1220 
   1221 
   1222 
   1223 ## ----------- ##
   1224 ##    Main.    ##
   1225 ## ----------- ##
   1226 
   1227 # func_lalib_p file
   1228 # True iff FILE is a libtool `.la' library or `.lo' object file.
   1229 # This function is only a basic sanity check; it will hardly flush out
   1230 # determined imposters.
   1231 func_lalib_p ()
   1232 {
   1233     test -f "$1" &&
   1234       $SED -e 4q "$1" 2>/dev/null \
   1235         | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
   1236 }
   1237 
   1238 # func_lalib_unsafe_p file
   1239 # True iff FILE is a libtool `.la' library or `.lo' object file.
   1240 # This function implements the same check as func_lalib_p without
   1241 # resorting to external programs.  To this end, it redirects stdin and
   1242 # closes it afterwards, without saving the original file descriptor.
   1243 # As a safety measure, use it only where a negative result would be
   1244 # fatal anyway.  Works if `file' does not exist.
   1245 func_lalib_unsafe_p ()
   1246 {
   1247     lalib_p=no
   1248     if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
   1249 	for lalib_p_l in 1 2 3 4
   1250 	do
   1251 	    read lalib_p_line
   1252 	    case "$lalib_p_line" in
   1253 		\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
   1254 	    esac
   1255 	done
   1256 	exec 0<&5 5<&-
   1257     fi
   1258     test "$lalib_p" = yes
   1259 }
   1260 
   1261 # func_ltwrapper_script_p file
   1262 # True iff FILE is a libtool wrapper script
   1263 # This function is only a basic sanity check; it will hardly flush out
   1264 # determined imposters.
   1265 func_ltwrapper_script_p ()
   1266 {
   1267     func_lalib_p "$1"
   1268 }
   1269 
   1270 # func_ltwrapper_executable_p file
   1271 # True iff FILE is a libtool wrapper executable
   1272 # This function is only a basic sanity check; it will hardly flush out
   1273 # determined imposters.
   1274 func_ltwrapper_executable_p ()
   1275 {
   1276     func_ltwrapper_exec_suffix=
   1277     case $1 in
   1278     *.exe) ;;
   1279     *) func_ltwrapper_exec_suffix=.exe ;;
   1280     esac
   1281     $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
   1282 }
   1283 
   1284 # func_ltwrapper_scriptname file
   1285 # Assumes file is an ltwrapper_executable
   1286 # uses $file to determine the appropriate filename for a
   1287 # temporary ltwrapper_script.
   1288 func_ltwrapper_scriptname ()
   1289 {
   1290     func_dirname_and_basename "$1" "" "."
   1291     func_stripname '' '.exe' "$func_basename_result"
   1292     func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
   1293 }
   1294 
   1295 # func_ltwrapper_p file
   1296 # True iff FILE is a libtool wrapper script or wrapper executable
   1297 # This function is only a basic sanity check; it will hardly flush out
   1298 # determined imposters.
   1299 func_ltwrapper_p ()
   1300 {
   1301     func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
   1302 }
   1303 
   1304 
   1305 # func_execute_cmds commands fail_cmd
   1306 # Execute tilde-delimited COMMANDS.
   1307 # If FAIL_CMD is given, eval that upon failure.
   1308 # FAIL_CMD may read-access the current command in variable CMD!
   1309 func_execute_cmds ()
   1310 {
   1311     $opt_debug
   1312     save_ifs=$IFS; IFS='~'
   1313     for cmd in $1; do
   1314       IFS=$save_ifs
   1315       eval cmd=\"$cmd\"
   1316       func_show_eval "$cmd" "${2-:}"
   1317     done
   1318     IFS=$save_ifs
   1319 }
   1320 
   1321 
   1322 # func_source file
   1323 # Source FILE, adding directory component if necessary.
   1324 # Note that it is not necessary on cygwin/mingw to append a dot to
   1325 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
   1326 # behavior happens only for exec(3), not for open(2)!  Also, sourcing
   1327 # `FILE.' does not work on cygwin managed mounts.
   1328 func_source ()
   1329 {
   1330     $opt_debug
   1331     case $1 in
   1332     */* | *\\*)	. "$1" ;;
   1333     *)		. "./$1" ;;
   1334     esac
   1335 }
   1336 
   1337 
   1338 # func_resolve_sysroot PATH
   1339 # Replace a leading = in PATH with a sysroot.  Store the result into
   1340 # func_resolve_sysroot_result
   1341 func_resolve_sysroot ()
   1342 {
   1343   func_resolve_sysroot_result=$1
   1344   case $func_resolve_sysroot_result in
   1345   =*)
   1346     func_stripname '=' '' "$func_resolve_sysroot_result"
   1347     func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
   1348     ;;
   1349   esac
   1350 }
   1351 
   1352 # func_replace_sysroot PATH
   1353 # If PATH begins with the sysroot, replace it with = and
   1354 # store the result into func_replace_sysroot_result.
   1355 func_replace_sysroot ()
   1356 {
   1357   case "$lt_sysroot:$1" in
   1358   ?*:"$lt_sysroot"*)
   1359     func_stripname "$lt_sysroot" '' "$1"
   1360     func_replace_sysroot_result="=$func_stripname_result"
   1361     ;;
   1362   *)
   1363     # Including no sysroot.
   1364     func_replace_sysroot_result=$1
   1365     ;;
   1366   esac
   1367 }
   1368 
   1369 # func_infer_tag arg
   1370 # Infer tagged configuration to use if any are available and
   1371 # if one wasn't chosen via the "--tag" command line option.
   1372 # Only attempt this if the compiler in the base compile
   1373 # command doesn't match the default compiler.
   1374 # arg is usually of the form 'gcc ...'
   1375 func_infer_tag ()
   1376 {
   1377     $opt_debug
   1378     if test -n "$available_tags" && test -z "$tagname"; then
   1379       CC_quoted=
   1380       for arg in $CC; do
   1381 	func_append_quoted CC_quoted "$arg"
   1382       done
   1383       CC_expanded=`func_echo_all $CC`
   1384       CC_quoted_expanded=`func_echo_all $CC_quoted`
   1385       case $@ in
   1386       # Blanks in the command may have been stripped by the calling shell,
   1387       # but not from the CC environment variable when configure was run.
   1388       " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
   1389       " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
   1390       # Blanks at the start of $base_compile will cause this to fail
   1391       # if we don't check for them as well.
   1392       *)
   1393 	for z in $available_tags; do
   1394 	  if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
   1395 	    # Evaluate the configuration.
   1396 	    eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
   1397 	    CC_quoted=
   1398 	    for arg in $CC; do
   1399 	      # Double-quote args containing other shell metacharacters.
   1400 	      func_append_quoted CC_quoted "$arg"
   1401 	    done
   1402 	    CC_expanded=`func_echo_all $CC`
   1403 	    CC_quoted_expanded=`func_echo_all $CC_quoted`
   1404 	    case "$@ " in
   1405 	    " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
   1406 	    " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
   1407 	      # The compiler in the base compile command matches
   1408 	      # the one in the tagged configuration.
   1409 	      # Assume this is the tagged configuration we want.
   1410 	      tagname=$z
   1411 	      break
   1412 	      ;;
   1413 	    esac
   1414 	  fi
   1415 	done
   1416 	# If $tagname still isn't set, then no tagged configuration
   1417 	# was found and let the user know that the "--tag" command
   1418 	# line option must be used.
   1419 	if test -z "$tagname"; then
   1420 	  func_echo "unable to infer tagged configuration"
   1421 	  func_fatal_error "specify a tag with \`--tag'"
   1422 #	else
   1423 #	  func_verbose "using $tagname tagged configuration"
   1424 	fi
   1425 	;;
   1426       esac
   1427     fi
   1428 }
   1429 
   1430 
   1431 
   1432 # func_write_libtool_object output_name pic_name nonpic_name
   1433 # Create a libtool object file (analogous to a ".la" file),
   1434 # but don't create it if we're doing a dry run.
   1435 func_write_libtool_object ()
   1436 {
   1437     write_libobj=${1}
   1438     if test "$build_libtool_libs" = yes; then
   1439       write_lobj=\'${2}\'
   1440     else
   1441       write_lobj=none
   1442     fi
   1443 
   1444     if test "$build_old_libs" = yes; then
   1445       write_oldobj=\'${3}\'
   1446     else
   1447       write_oldobj=none
   1448     fi
   1449 
   1450     $opt_dry_run || {
   1451       cat >${write_libobj}T <<EOF
   1452 # $write_libobj - a libtool object file
   1453 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
   1454 #
   1455 # Please DO NOT delete this file!
   1456 # It is necessary for linking the library.
   1457 
   1458 # Name of the PIC object.
   1459 pic_object=$write_lobj
   1460 
   1461 # Name of the non-PIC object
   1462 non_pic_object=$write_oldobj
   1463 
   1464 EOF
   1465       $MV "${write_libobj}T" "${write_libobj}"
   1466     }
   1467 }
   1468 
   1469 
   1470 ##################################################
   1471 # FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
   1472 ##################################################
   1473 
   1474 # func_convert_core_file_wine_to_w32 ARG
   1475 # Helper function used by file name conversion functions when $build is *nix,
   1476 # and $host is mingw, cygwin, or some other w32 environment. Relies on a
   1477 # correctly configured wine environment available, with the winepath program
   1478 # in $build's $PATH.
   1479 #
   1480 # ARG is the $build file name to be converted to w32 format.
   1481 # Result is available in $func_convert_core_file_wine_to_w32_result, and will
   1482 # be empty on error (or when ARG is empty)
   1483 func_convert_core_file_wine_to_w32 ()
   1484 {
   1485   $opt_debug
   1486   func_convert_core_file_wine_to_w32_result="$1"
   1487   if test -n "$1"; then
   1488     # Unfortunately, winepath does not exit with a non-zero error code, so we
   1489     # are forced to check the contents of stdout. On the other hand, if the
   1490     # command is not found, the shell will set an exit code of 127 and print
   1491     # *an error message* to stdout. So we must check for both error code of
   1492     # zero AND non-empty stdout, which explains the odd construction:
   1493     func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
   1494     if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
   1495       func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
   1496         $SED -e "$lt_sed_naive_backslashify"`
   1497     else
   1498       func_convert_core_file_wine_to_w32_result=
   1499     fi
   1500   fi
   1501 }
   1502 # end: func_convert_core_file_wine_to_w32
   1503 
   1504 
   1505 # func_convert_core_path_wine_to_w32 ARG
   1506 # Helper function used by path conversion functions when $build is *nix, and
   1507 # $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
   1508 # configured wine environment available, with the winepath program in $build's
   1509 # $PATH. Assumes ARG has no leading or trailing path separator characters.
   1510 #
   1511 # ARG is path to be converted from $build format to win32.
   1512 # Result is available in $func_convert_core_path_wine_to_w32_result.
   1513 # Unconvertible file (directory) names in ARG are skipped; if no directory names
   1514 # are convertible, then the result may be empty.
   1515 func_convert_core_path_wine_to_w32 ()
   1516 {
   1517   $opt_debug
   1518   # unfortunately, winepath doesn't convert paths, only file names
   1519   func_convert_core_path_wine_to_w32_result=""
   1520   if test -n "$1"; then
   1521     oldIFS=$IFS
   1522     IFS=:
   1523     for func_convert_core_path_wine_to_w32_f in $1; do
   1524       IFS=$oldIFS
   1525       func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
   1526       if test -n "$func_convert_core_file_wine_to_w32_result" ; then
   1527         if test -z "$func_convert_core_path_wine_to_w32_result"; then
   1528           func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
   1529         else
   1530           func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
   1531         fi
   1532       fi
   1533     done
   1534     IFS=$oldIFS
   1535   fi
   1536 }
   1537 # end: func_convert_core_path_wine_to_w32
   1538 
   1539 
   1540 # func_cygpath ARGS...
   1541 # Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
   1542 # when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
   1543 # $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
   1544 # (2), returns the Cygwin file name or path in func_cygpath_result (input
   1545 # file name or path is assumed to be in w32 format, as previously converted
   1546 # from $build's *nix or MSYS format). In case (3), returns the w32 file name
   1547 # or path in func_cygpath_result (input file name or path is assumed to be in
   1548 # Cygwin format). Returns an empty string on error.
   1549 #
   1550 # ARGS are passed to cygpath, with the last one being the file name or path to
   1551 # be converted.
   1552 #
   1553 # Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
   1554 # environment variable; do not put it in $PATH.
   1555 func_cygpath ()
   1556 {
   1557   $opt_debug
   1558   if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
   1559     func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
   1560     if test "$?" -ne 0; then
   1561       # on failure, ensure result is empty
   1562       func_cygpath_result=
   1563     fi
   1564   else
   1565     func_cygpath_result=
   1566     func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
   1567   fi
   1568 }
   1569 #end: func_cygpath
   1570 
   1571 
   1572 # func_convert_core_msys_to_w32 ARG
   1573 # Convert file name or path ARG from MSYS format to w32 format.  Return
   1574 # result in func_convert_core_msys_to_w32_result.
   1575 func_convert_core_msys_to_w32 ()
   1576 {
   1577   $opt_debug
   1578   # awkward: cmd appends spaces to result
   1579   func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
   1580     $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
   1581 }
   1582 #end: func_convert_core_msys_to_w32
   1583 
   1584 
   1585 # func_convert_file_check ARG1 ARG2
   1586 # Verify that ARG1 (a file name in $build format) was converted to $host
   1587 # format in ARG2. Otherwise, emit an error message, but continue (resetting
   1588 # func_to_host_file_result to ARG1).
   1589 func_convert_file_check ()
   1590 {
   1591   $opt_debug
   1592   if test -z "$2" && test -n "$1" ; then
   1593     func_error "Could not determine host file name corresponding to"
   1594     func_error "  \`$1'"
   1595     func_error "Continuing, but uninstalled executables may not work."
   1596     # Fallback:
   1597     func_to_host_file_result="$1"
   1598   fi
   1599 }
   1600 # end func_convert_file_check
   1601 
   1602 
   1603 # func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
   1604 # Verify that FROM_PATH (a path in $build format) was converted to $host
   1605 # format in TO_PATH. Otherwise, emit an error message, but continue, resetting
   1606 # func_to_host_file_result to a simplistic fallback value (see below).
   1607 func_convert_path_check ()
   1608 {
   1609   $opt_debug
   1610   if test -z "$4" && test -n "$3"; then
   1611     func_error "Could not determine the host path corresponding to"
   1612     func_error "  \`$3'"
   1613     func_error "Continuing, but uninstalled executables may not work."
   1614     # Fallback.  This is a deliberately simplistic "conversion" and
   1615     # should not be "improved".  See libtool.info.
   1616     if test "x$1" != "x$2"; then
   1617       lt_replace_pathsep_chars="s|$1|$2|g"
   1618       func_to_host_path_result=`echo "$3" |
   1619         $SED -e "$lt_replace_pathsep_chars"`
   1620     else
   1621       func_to_host_path_result="$3"
   1622     fi
   1623   fi
   1624 }
   1625 # end func_convert_path_check
   1626 
   1627 
   1628 # func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
   1629 # Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
   1630 # and appending REPL if ORIG matches BACKPAT.
   1631 func_convert_path_front_back_pathsep ()
   1632 {
   1633   $opt_debug
   1634   case $4 in
   1635   $1 ) func_to_host_path_result="$3$func_to_host_path_result"
   1636     ;;
   1637   esac
   1638   case $4 in
   1639   $2 ) func_append func_to_host_path_result "$3"
   1640     ;;
   1641   esac
   1642 }
   1643 # end func_convert_path_front_back_pathsep
   1644 
   1645 
   1646 ##################################################
   1647 # $build to $host FILE NAME CONVERSION FUNCTIONS #
   1648 ##################################################
   1649 # invoked via `$to_host_file_cmd ARG'
   1650 #
   1651 # In each case, ARG is the path to be converted from $build to $host format.
   1652 # Result will be available in $func_to_host_file_result.
   1653 
   1654 
   1655 # func_to_host_file ARG
   1656 # Converts the file name ARG from $build format to $host format. Return result
   1657 # in func_to_host_file_result.
   1658 func_to_host_file ()
   1659 {
   1660   $opt_debug
   1661   $to_host_file_cmd "$1"
   1662 }
   1663 # end func_to_host_file
   1664 
   1665 
   1666 # func_to_tool_file ARG LAZY
   1667 # converts the file name ARG from $build format to toolchain format. Return
   1668 # result in func_to_tool_file_result.  If the conversion in use is listed
   1669 # in (the comma separated) LAZY, no conversion takes place.
   1670 func_to_tool_file ()
   1671 {
   1672   $opt_debug
   1673   case ,$2, in
   1674     *,"$to_tool_file_cmd",*)
   1675       func_to_tool_file_result=$1
   1676       ;;
   1677     *)
   1678       $to_tool_file_cmd "$1"
   1679       func_to_tool_file_result=$func_to_host_file_result
   1680       ;;
   1681   esac
   1682 }
   1683 # end func_to_tool_file
   1684 
   1685 
   1686 # func_convert_file_noop ARG
   1687 # Copy ARG to func_to_host_file_result.
   1688 func_convert_file_noop ()
   1689 {
   1690   func_to_host_file_result="$1"
   1691 }
   1692 # end func_convert_file_noop
   1693 
   1694 
   1695 # func_convert_file_msys_to_w32 ARG
   1696 # Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
   1697 # conversion to w32 is not available inside the cwrapper.  Returns result in
   1698 # func_to_host_file_result.
   1699 func_convert_file_msys_to_w32 ()
   1700 {
   1701   $opt_debug
   1702   func_to_host_file_result="$1"
   1703   if test -n "$1"; then
   1704     func_convert_core_msys_to_w32 "$1"
   1705     func_to_host_file_result="$func_convert_core_msys_to_w32_result"
   1706   fi
   1707   func_convert_file_check "$1" "$func_to_host_file_result"
   1708 }
   1709 # end func_convert_file_msys_to_w32
   1710 
   1711 
   1712 # func_convert_file_cygwin_to_w32 ARG
   1713 # Convert file name ARG from Cygwin to w32 format.  Returns result in
   1714 # func_to_host_file_result.
   1715 func_convert_file_cygwin_to_w32 ()
   1716 {
   1717   $opt_debug
   1718   func_to_host_file_result="$1"
   1719   if test -n "$1"; then
   1720     # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
   1721     # LT_CYGPATH in this case.
   1722     func_to_host_file_result=`cygpath -m "$1"`
   1723   fi
   1724   func_convert_file_check "$1" "$func_to_host_file_result"
   1725 }
   1726 # end func_convert_file_cygwin_to_w32
   1727 
   1728 
   1729 # func_convert_file_nix_to_w32 ARG
   1730 # Convert file name ARG from *nix to w32 format.  Requires a wine environment
   1731 # and a working winepath. Returns result in func_to_host_file_result.
   1732 func_convert_file_nix_to_w32 ()
   1733 {
   1734   $opt_debug
   1735   func_to_host_file_result="$1"
   1736   if test -n "$1"; then
   1737     func_convert_core_file_wine_to_w32 "$1"
   1738     func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
   1739   fi
   1740   func_convert_file_check "$1" "$func_to_host_file_result"
   1741 }
   1742 # end func_convert_file_nix_to_w32
   1743 
   1744 
   1745 # func_convert_file_msys_to_cygwin ARG
   1746 # Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
   1747 # Returns result in func_to_host_file_result.
   1748 func_convert_file_msys_to_cygwin ()
   1749 {
   1750   $opt_debug
   1751   func_to_host_file_result="$1"
   1752   if test -n "$1"; then
   1753     func_convert_core_msys_to_w32 "$1"
   1754     func_cygpath -u "$func_convert_core_msys_to_w32_result"
   1755     func_to_host_file_result="$func_cygpath_result"
   1756   fi
   1757   func_convert_file_check "$1" "$func_to_host_file_result"
   1758 }
   1759 # end func_convert_file_msys_to_cygwin
   1760 
   1761 
   1762 # func_convert_file_nix_to_cygwin ARG
   1763 # Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
   1764 # in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
   1765 # in func_to_host_file_result.
   1766 func_convert_file_nix_to_cygwin ()
   1767 {
   1768   $opt_debug
   1769   func_to_host_file_result="$1"
   1770   if test -n "$1"; then
   1771     # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
   1772     func_convert_core_file_wine_to_w32 "$1"
   1773     func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
   1774     func_to_host_file_result="$func_cygpath_result"
   1775   fi
   1776   func_convert_file_check "$1" "$func_to_host_file_result"
   1777 }
   1778 # end func_convert_file_nix_to_cygwin
   1779 
   1780 
   1781 #############################################
   1782 # $build to $host PATH CONVERSION FUNCTIONS #
   1783 #############################################
   1784 # invoked via `$to_host_path_cmd ARG'
   1785 #
   1786 # In each case, ARG is the path to be converted from $build to $host format.
   1787 # The result will be available in $func_to_host_path_result.
   1788 #
   1789 # Path separators are also converted from $build format to $host format.  If
   1790 # ARG begins or ends with a path separator character, it is preserved (but
   1791 # converted to $host format) on output.
   1792 #
   1793 # All path conversion functions are named using the following convention:
   1794 #   file name conversion function    : func_convert_file_X_to_Y ()
   1795 #   path conversion function         : func_convert_path_X_to_Y ()
   1796 # where, for any given $build/$host combination the 'X_to_Y' value is the
   1797 # same.  If conversion functions are added for new $build/$host combinations,
   1798 # the two new functions must follow this pattern, or func_init_to_host_path_cmd
   1799 # will break.
   1800 
   1801 
   1802 # func_init_to_host_path_cmd
   1803 # Ensures that function "pointer" variable $to_host_path_cmd is set to the
   1804 # appropriate value, based on the value of $to_host_file_cmd.
   1805 to_host_path_cmd=
   1806 func_init_to_host_path_cmd ()
   1807 {
   1808   $opt_debug
   1809   if test -z "$to_host_path_cmd"; then
   1810     func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
   1811     to_host_path_cmd="func_convert_path_${func_stripname_result}"
   1812   fi
   1813 }
   1814 
   1815 
   1816 # func_to_host_path ARG
   1817 # Converts the path ARG from $build format to $host format. Return result
   1818 # in func_to_host_path_result.
   1819 func_to_host_path ()
   1820 {
   1821   $opt_debug
   1822   func_init_to_host_path_cmd
   1823   $to_host_path_cmd "$1"
   1824 }
   1825 # end func_to_host_path
   1826 
   1827 
   1828 # func_convert_path_noop ARG
   1829 # Copy ARG to func_to_host_path_result.
   1830 func_convert_path_noop ()
   1831 {
   1832   func_to_host_path_result="$1"
   1833 }
   1834 # end func_convert_path_noop
   1835 
   1836 
   1837 # func_convert_path_msys_to_w32 ARG
   1838 # Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
   1839 # conversion to w32 is not available inside the cwrapper.  Returns result in
   1840 # func_to_host_path_result.
   1841 func_convert_path_msys_to_w32 ()
   1842 {
   1843   $opt_debug
   1844   func_to_host_path_result="$1"
   1845   if test -n "$1"; then
   1846     # Remove leading and trailing path separator characters from ARG.  MSYS
   1847     # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
   1848     # and winepath ignores them completely.
   1849     func_stripname : : "$1"
   1850     func_to_host_path_tmp1=$func_stripname_result
   1851     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
   1852     func_to_host_path_result="$func_convert_core_msys_to_w32_result"
   1853     func_convert_path_check : ";" \
   1854       "$func_to_host_path_tmp1" "$func_to_host_path_result"
   1855     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
   1856   fi
   1857 }
   1858 # end func_convert_path_msys_to_w32
   1859 
   1860 
   1861 # func_convert_path_cygwin_to_w32 ARG
   1862 # Convert path ARG from Cygwin to w32 format.  Returns result in
   1863 # func_to_host_file_result.
   1864 func_convert_path_cygwin_to_w32 ()
   1865 {
   1866   $opt_debug
   1867   func_to_host_path_result="$1"
   1868   if test -n "$1"; then
   1869     # See func_convert_path_msys_to_w32:
   1870     func_stripname : : "$1"
   1871     func_to_host_path_tmp1=$func_stripname_result
   1872     func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
   1873     func_convert_path_check : ";" \
   1874       "$func_to_host_path_tmp1" "$func_to_host_path_result"
   1875     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
   1876   fi
   1877 }
   1878 # end func_convert_path_cygwin_to_w32
   1879 
   1880 
   1881 # func_convert_path_nix_to_w32 ARG
   1882 # Convert path ARG from *nix to w32 format.  Requires a wine environment and
   1883 # a working winepath.  Returns result in func_to_host_file_result.
   1884 func_convert_path_nix_to_w32 ()
   1885 {
   1886   $opt_debug
   1887   func_to_host_path_result="$1"
   1888   if test -n "$1"; then
   1889     # See func_convert_path_msys_to_w32:
   1890     func_stripname : : "$1"
   1891     func_to_host_path_tmp1=$func_stripname_result
   1892     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
   1893     func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
   1894     func_convert_path_check : ";" \
   1895       "$func_to_host_path_tmp1" "$func_to_host_path_result"
   1896     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
   1897   fi
   1898 }
   1899 # end func_convert_path_nix_to_w32
   1900 
   1901 
   1902 # func_convert_path_msys_to_cygwin ARG
   1903 # Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
   1904 # Returns result in func_to_host_file_result.
   1905 func_convert_path_msys_to_cygwin ()
   1906 {
   1907   $opt_debug
   1908   func_to_host_path_result="$1"
   1909   if test -n "$1"; then
   1910     # See func_convert_path_msys_to_w32:
   1911     func_stripname : : "$1"
   1912     func_to_host_path_tmp1=$func_stripname_result
   1913     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
   1914     func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
   1915     func_to_host_path_result="$func_cygpath_result"
   1916     func_convert_path_check : : \
   1917       "$func_to_host_path_tmp1" "$func_to_host_path_result"
   1918     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
   1919   fi
   1920 }
   1921 # end func_convert_path_msys_to_cygwin
   1922 
   1923 
   1924 # func_convert_path_nix_to_cygwin ARG
   1925 # Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
   1926 # a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
   1927 # func_to_host_file_result.
   1928 func_convert_path_nix_to_cygwin ()
   1929 {
   1930   $opt_debug
   1931   func_to_host_path_result="$1"
   1932   if test -n "$1"; then
   1933     # Remove leading and trailing path separator characters from
   1934     # ARG. msys behavior is inconsistent here, cygpath turns them
   1935     # into '.;' and ';.', and winepath ignores them completely.
   1936     func_stripname : : "$1"
   1937     func_to_host_path_tmp1=$func_stripname_result
   1938     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
   1939     func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
   1940     func_to_host_path_result="$func_cygpath_result"
   1941     func_convert_path_check : : \
   1942       "$func_to_host_path_tmp1" "$func_to_host_path_result"
   1943     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
   1944   fi
   1945 }
   1946 # end func_convert_path_nix_to_cygwin
   1947 
   1948 
   1949 # func_mode_compile arg...
   1950 func_mode_compile ()
   1951 {
   1952     $opt_debug
   1953     # Get the compilation command and the source file.
   1954     base_compile=
   1955     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
   1956     suppress_opt=yes
   1957     suppress_output=
   1958     arg_mode=normal
   1959     libobj=
   1960     later=
   1961     pie_flag=
   1962 
   1963     for arg
   1964     do
   1965       case $arg_mode in
   1966       arg  )
   1967 	# do not "continue".  Instead, add this to base_compile
   1968 	lastarg="$arg"
   1969 	arg_mode=normal
   1970 	;;
   1971 
   1972       target )
   1973 	libobj="$arg"
   1974 	arg_mode=normal
   1975 	continue
   1976 	;;
   1977 
   1978       normal )
   1979 	# Accept any command-line options.
   1980 	case $arg in
   1981 	-o)
   1982 	  test -n "$libobj" && \
   1983 	    func_fatal_error "you cannot specify \`-o' more than once"
   1984 	  arg_mode=target
   1985 	  continue
   1986 	  ;;
   1987 
   1988 	-pie | -fpie | -fPIE)
   1989           func_append pie_flag " $arg"
   1990 	  continue
   1991 	  ;;
   1992 
   1993 	-shared | -static | -prefer-pic | -prefer-non-pic)
   1994 	  func_append later " $arg"
   1995 	  continue
   1996 	  ;;
   1997 
   1998 	-no-suppress)
   1999 	  suppress_opt=no
   2000 	  continue
   2001 	  ;;
   2002 
   2003 	-Xcompiler)
   2004 	  arg_mode=arg  #  the next one goes into the "base_compile" arg list
   2005 	  continue      #  The current "srcfile" will either be retained or
   2006 	  ;;            #  replaced later.  I would guess that would be a bug.
   2007 
   2008 	-Wc,*)
   2009 	  func_stripname '-Wc,' '' "$arg"
   2010 	  args=$func_stripname_result
   2011 	  lastarg=
   2012 	  save_ifs="$IFS"; IFS=','
   2013 	  for arg in $args; do
   2014 	    IFS="$save_ifs"
   2015 	    func_append_quoted lastarg "$arg"
   2016 	  done
   2017 	  IFS="$save_ifs"
   2018 	  func_stripname ' ' '' "$lastarg"
   2019 	  lastarg=$func_stripname_result
   2020 
   2021 	  # Add the arguments to base_compile.
   2022 	  func_append base_compile " $lastarg"
   2023 	  continue
   2024 	  ;;
   2025 
   2026 	*)
   2027 	  # Accept the current argument as the source file.
   2028 	  # The previous "srcfile" becomes the current argument.
   2029 	  #
   2030 	  lastarg="$srcfile"
   2031 	  srcfile="$arg"
   2032 	  ;;
   2033 	esac  #  case $arg
   2034 	;;
   2035       esac    #  case $arg_mode
   2036 
   2037       # Aesthetically quote the previous argument.
   2038       func_append_quoted base_compile "$lastarg"
   2039     done # for arg
   2040 
   2041     case $arg_mode in
   2042     arg)
   2043       func_fatal_error "you must specify an argument for -Xcompile"
   2044       ;;
   2045     target)
   2046       func_fatal_error "you must specify a target with \`-o'"
   2047       ;;
   2048     *)
   2049       # Get the name of the library object.
   2050       test -z "$libobj" && {
   2051 	func_basename "$srcfile"
   2052 	libobj="$func_basename_result"
   2053       }
   2054       ;;
   2055     esac
   2056 
   2057     # Recognize several different file suffixes.
   2058     # If the user specifies -o file.o, it is replaced with file.lo
   2059     case $libobj in
   2060     *.[cCFSifmso] | \
   2061     *.ada | *.adb | *.ads | *.asm | \
   2062     *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
   2063     *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
   2064       func_xform "$libobj"
   2065       libobj=$func_xform_result
   2066       ;;
   2067     esac
   2068 
   2069     case $libobj in
   2070     *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
   2071     *)
   2072       func_fatal_error "cannot determine name of library object from \`$libobj'"
   2073       ;;
   2074     esac
   2075 
   2076     func_infer_tag $base_compile
   2077 
   2078     for arg in $later; do
   2079       case $arg in
   2080       -shared)
   2081 	test "$build_libtool_libs" != yes && \
   2082 	  func_fatal_configuration "can not build a shared library"
   2083 	build_old_libs=no
   2084 	continue
   2085 	;;
   2086 
   2087       -static)
   2088 	build_libtool_libs=no
   2089 	build_old_libs=yes
   2090 	continue
   2091 	;;
   2092 
   2093       -prefer-pic)
   2094 	pic_mode=yes
   2095 	continue
   2096 	;;
   2097 
   2098       -prefer-non-pic)
   2099 	pic_mode=no
   2100 	continue
   2101 	;;
   2102       esac
   2103     done
   2104 
   2105     func_quote_for_eval "$libobj"
   2106     test "X$libobj" != "X$func_quote_for_eval_result" \
   2107       && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'	 &()|`$[]' \
   2108       && func_warning "libobj name \`$libobj' may not contain shell special characters."
   2109     func_dirname_and_basename "$obj" "/" ""
   2110     objname="$func_basename_result"
   2111     xdir="$func_dirname_result"
   2112     lobj=${xdir}$objdir/$objname
   2113 
   2114     test -z "$base_compile" && \
   2115       func_fatal_help "you must specify a compilation command"
   2116 
   2117     # Delete any leftover library objects.
   2118     if test "$build_old_libs" = yes; then
   2119       removelist="$obj $lobj $libobj ${libobj}T"
   2120     else
   2121       removelist="$lobj $libobj ${libobj}T"
   2122     fi
   2123 
   2124     # On Cygwin there's no "real" PIC flag so we must build both object types
   2125     case $host_os in
   2126     cygwin* | mingw* | pw32* | os2* | cegcc*)
   2127       pic_mode=default
   2128       ;;
   2129     esac
   2130     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
   2131       # non-PIC code in shared libraries is not supported
   2132       pic_mode=default
   2133     fi
   2134 
   2135     # Calculate the filename of the output object if compiler does
   2136     # not support -o with -c
   2137     if test "$compiler_c_o" = no; then
   2138       output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
   2139       lockfile="$output_obj.lock"
   2140     else
   2141       output_obj=
   2142       need_locks=no
   2143       lockfile=
   2144     fi
   2145 
   2146     # Lock this critical section if it is needed
   2147     # We use this script file to make the link, it avoids creating a new file
   2148     if test "$need_locks" = yes; then
   2149       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
   2150 	func_echo "Waiting for $lockfile to be removed"
   2151 	sleep 2
   2152       done
   2153     elif test "$need_locks" = warn; then
   2154       if test -f "$lockfile"; then
   2155 	$ECHO "\
   2156 *** ERROR, $lockfile exists and contains:
   2157 `cat $lockfile 2>/dev/null`
   2158 
   2159 This indicates that another process is trying to use the same
   2160 temporary object file, and libtool could not work around it because
   2161 your compiler does not support \`-c' and \`-o' together.  If you
   2162 repeat this compilation, it may succeed, by chance, but you had better
   2163 avoid parallel builds (make -j) in this platform, or get a better
   2164 compiler."
   2165 
   2166 	$opt_dry_run || $RM $removelist
   2167 	exit $EXIT_FAILURE
   2168       fi
   2169       func_append removelist " $output_obj"
   2170       $ECHO "$srcfile" > "$lockfile"
   2171     fi
   2172 
   2173     $opt_dry_run || $RM $removelist
   2174     func_append removelist " $lockfile"
   2175     trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
   2176 
   2177     func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
   2178     srcfile=$func_to_tool_file_result
   2179     func_quote_for_eval "$srcfile"
   2180     qsrcfile=$func_quote_for_eval_result
   2181 
   2182     # Only build a PIC object if we are building libtool libraries.
   2183     if test "$build_libtool_libs" = yes; then
   2184       # Without this assignment, base_compile gets emptied.
   2185       fbsd_hideous_sh_bug=$base_compile
   2186 
   2187       if test "$pic_mode" != no; then
   2188 	command="$base_compile $qsrcfile $pic_flag"
   2189       else
   2190 	# Don't build PIC code
   2191 	command="$base_compile $qsrcfile"
   2192       fi
   2193 
   2194       func_mkdir_p "$xdir$objdir"
   2195 
   2196       if test -z "$output_obj"; then
   2197 	# Place PIC objects in $objdir
   2198 	func_append command " -o $lobj"
   2199       fi
   2200 
   2201       func_show_eval_locale "$command"	\
   2202           'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
   2203 
   2204       if test "$need_locks" = warn &&
   2205 	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
   2206 	$ECHO "\
   2207 *** ERROR, $lockfile contains:
   2208 `cat $lockfile 2>/dev/null`
   2209 
   2210 but it should contain:
   2211 $srcfile
   2212 
   2213 This indicates that another process is trying to use the same
   2214 temporary object file, and libtool could not work around it because
   2215 your compiler does not support \`-c' and \`-o' together.  If you
   2216 repeat this compilation, it may succeed, by chance, but you had better
   2217 avoid parallel builds (make -j) in this platform, or get a better
   2218 compiler."
   2219 
   2220 	$opt_dry_run || $RM $removelist
   2221 	exit $EXIT_FAILURE
   2222       fi
   2223 
   2224       # Just move the object if needed, then go on to compile the next one
   2225       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
   2226 	func_show_eval '$MV "$output_obj" "$lobj"' \
   2227 	  'error=$?; $opt_dry_run || $RM $removelist; exit $error'
   2228       fi
   2229 
   2230       # Allow error messages only from the first compilation.
   2231       if test "$suppress_opt" = yes; then
   2232 	suppress_output=' >/dev/null 2>&1'
   2233       fi
   2234     fi
   2235 
   2236     # Only build a position-dependent object if we build old libraries.
   2237     if test "$build_old_libs" = yes; then
   2238       if test "$pic_mode" != yes; then
   2239 	# Don't build PIC code
   2240 	command="$base_compile $qsrcfile$pie_flag"
   2241       else
   2242 	command="$base_compile $qsrcfile $pic_flag"
   2243       fi
   2244       if test "$compiler_c_o" = yes; then
   2245 	func_append command " -o $obj"
   2246       fi
   2247 
   2248       # Suppress compiler output if we already did a PIC compilation.
   2249       func_append command "$suppress_output"
   2250       func_show_eval_locale "$command" \
   2251         '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
   2252 
   2253       if test "$need_locks" = warn &&
   2254 	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
   2255 	$ECHO "\
   2256 *** ERROR, $lockfile contains:
   2257 `cat $lockfile 2>/dev/null`
   2258 
   2259 but it should contain:
   2260 $srcfile
   2261 
   2262 This indicates that another process is trying to use the same
   2263 temporary object file, and libtool could not work around it because
   2264 your compiler does not support \`-c' and \`-o' together.  If you
   2265 repeat this compilation, it may succeed, by chance, but you had better
   2266 avoid parallel builds (make -j) in this platform, or get a better
   2267 compiler."
   2268 
   2269 	$opt_dry_run || $RM $removelist
   2270 	exit $EXIT_FAILURE
   2271       fi
   2272 
   2273       # Just move the object if needed
   2274       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
   2275 	func_show_eval '$MV "$output_obj" "$obj"' \
   2276 	  'error=$?; $opt_dry_run || $RM $removelist; exit $error'
   2277       fi
   2278     fi
   2279 
   2280     $opt_dry_run || {
   2281       func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
   2282 
   2283       # Unlock the critical section if it was locked
   2284       if test "$need_locks" != no; then
   2285 	removelist=$lockfile
   2286         $RM "$lockfile"
   2287       fi
   2288     }
   2289 
   2290     exit $EXIT_SUCCESS
   2291 }
   2292 
   2293 $opt_help || {
   2294   test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
   2295 }
   2296 
   2297 func_mode_help ()
   2298 {
   2299     # We need to display help for each of the modes.
   2300     case $opt_mode in
   2301       "")
   2302         # Generic help is extracted from the usage comments
   2303         # at the start of this file.
   2304         func_help
   2305         ;;
   2306 
   2307       clean)
   2308         $ECHO \
   2309 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
   2310 
   2311 Remove files from the build directory.
   2312 
   2313 RM is the name of the program to use to delete files associated with each FILE
   2314 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
   2315 to RM.
   2316 
   2317 If FILE is a libtool library, object or program, all the files associated
   2318 with it are deleted. Otherwise, only FILE itself is deleted using RM."
   2319         ;;
   2320 
   2321       compile)
   2322       $ECHO \
   2323 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
   2324 
   2325 Compile a source file into a libtool library object.
   2326 
   2327 This mode accepts the following additional options:
   2328 
   2329   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
   2330   -no-suppress      do not suppress compiler output for multiple passes
   2331   -prefer-pic       try to build PIC objects only
   2332   -prefer-non-pic   try to build non-PIC objects only
   2333   -shared           do not build a \`.o' file suitable for static linking
   2334   -static           only build a \`.o' file suitable for static linking
   2335   -Wc,FLAG          pass FLAG directly to the compiler
   2336 
   2337 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
   2338 from the given SOURCEFILE.
   2339 
   2340 The output file name is determined by removing the directory component from
   2341 SOURCEFILE, then substituting the C source code suffix \`.c' with the
   2342 library object suffix, \`.lo'."
   2343         ;;
   2344 
   2345       execute)
   2346         $ECHO \
   2347 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
   2348 
   2349 Automatically set library path, then run a program.
   2350 
   2351 This mode accepts the following additional options:
   2352 
   2353   -dlopen FILE      add the directory containing FILE to the library path
   2354 
   2355 This mode sets the library path environment variable according to \`-dlopen'
   2356 flags.
   2357 
   2358 If any of the ARGS are libtool executable wrappers, then they are translated
   2359 into their corresponding uninstalled binary, and any of their required library
   2360 directories are added to the library path.
   2361 
   2362 Then, COMMAND is executed, with ARGS as arguments."
   2363         ;;
   2364 
   2365       finish)
   2366         $ECHO \
   2367 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
   2368 
   2369 Complete the installation of libtool libraries.
   2370 
   2371 Each LIBDIR is a directory that contains libtool libraries.
   2372 
   2373 The commands that this mode executes may require superuser privileges.  Use
   2374 the \`--dry-run' option if you just want to see what would be executed."
   2375         ;;
   2376 
   2377       install)
   2378         $ECHO \
   2379 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
   2380 
   2381 Install executables or libraries.
   2382 
   2383 INSTALL-COMMAND is the installation command.  The first component should be
   2384 either the \`install' or \`cp' program.
   2385 
   2386 The following components of INSTALL-COMMAND are treated specially:
   2387 
   2388   -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
   2389 
   2390 The rest of the components are interpreted as arguments to that command (only
   2391 BSD-compatible install options are recognized)."
   2392         ;;
   2393 
   2394       link)
   2395         $ECHO \
   2396 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
   2397 
   2398 Link object files or libraries together to form another library, or to
   2399 create an executable program.
   2400 
   2401 LINK-COMMAND is a command using the C compiler that you would use to create
   2402 a program from several object files.
   2403 
   2404 The following components of LINK-COMMAND are treated specially:
   2405 
   2406   -all-static       do not do any dynamic linking at all
   2407   -avoid-version    do not add a version suffix if possible
   2408   -bindir BINDIR    specify path to binaries directory (for systems where
   2409                     libraries must be found in the PATH setting at runtime)
   2410   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
   2411   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
   2412   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
   2413   -export-symbols SYMFILE
   2414                     try to export only the symbols listed in SYMFILE
   2415   -export-symbols-regex REGEX
   2416                     try to export only the symbols matching REGEX
   2417   -LLIBDIR          search LIBDIR for required installed libraries
   2418   -lNAME            OUTPUT-FILE requires the installed library libNAME
   2419   -module           build a library that can dlopened
   2420   -no-fast-install  disable the fast-install mode
   2421   -no-install       link a not-installable executable
   2422   -no-undefined     declare that a library does not refer to external symbols
   2423   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
   2424   -objectlist FILE  Use a list of object files found in FILE to specify objects
   2425   -precious-files-regex REGEX
   2426                     don't remove output files matching REGEX
   2427   -release RELEASE  specify package release information
   2428   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
   2429   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
   2430   -shared           only do dynamic linking of libtool libraries
   2431   -shrext SUFFIX    override the standard shared library file extension
   2432   -static           do not do any dynamic linking of uninstalled libtool libraries
   2433   -static-libtool-libs
   2434                     do not do any dynamic linking of libtool libraries
   2435   -version-info CURRENT[:REVISION[:AGE]]
   2436                     specify library version info [each variable defaults to 0]
   2437   -weak LIBNAME     declare that the target provides the LIBNAME interface
   2438   -Wc,FLAG
   2439   -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
   2440   -Wl,FLAG
   2441   -Xlinker FLAG     pass linker-specific FLAG directly to the linker
   2442   -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
   2443 
   2444 All other options (arguments beginning with \`-') are ignored.
   2445 
   2446 Every other argument is treated as a filename.  Files ending in \`.la' are
   2447 treated as uninstalled libtool libraries, other files are standard or library
   2448 object files.
   2449 
   2450 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
   2451 only library objects (\`.lo' files) may be specified, and \`-rpath' is
   2452 required, except when creating a convenience library.
   2453 
   2454 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
   2455 using \`ar' and \`ranlib', or on Windows using \`lib'.
   2456 
   2457 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
   2458 is created, otherwise an executable program is created."
   2459         ;;
   2460 
   2461       uninstall)
   2462         $ECHO \
   2463 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
   2464 
   2465 Remove libraries from an installation directory.
   2466 
   2467 RM is the name of the program to use to delete files associated with each FILE
   2468 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
   2469 to RM.
   2470 
   2471 If FILE is a libtool library, all the files associated with it are deleted.
   2472 Otherwise, only FILE itself is deleted using RM."
   2473         ;;
   2474 
   2475       *)
   2476         func_fatal_help "invalid operation mode \`$opt_mode'"
   2477         ;;
   2478     esac
   2479 
   2480     echo
   2481     $ECHO "Try \`$progname --help' for more information about other modes."
   2482 }
   2483 
   2484 # Now that we've collected a possible --mode arg, show help if necessary
   2485 if $opt_help; then
   2486   if test "$opt_help" = :; then
   2487     func_mode_help
   2488   else
   2489     {
   2490       func_help noexit
   2491       for opt_mode in compile link execute install finish uninstall clean; do
   2492 	func_mode_help
   2493       done
   2494     } | sed -n '1p; 2,$s/^Usage:/  or: /p'
   2495     {
   2496       func_help noexit
   2497       for opt_mode in compile link execute install finish uninstall clean; do
   2498 	echo
   2499 	func_mode_help
   2500       done
   2501     } |
   2502     sed '1d
   2503       /^When reporting/,/^Report/{
   2504 	H
   2505 	d
   2506       }
   2507       $x
   2508       /information about other modes/d
   2509       /more detailed .*MODE/d
   2510       s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
   2511   fi
   2512   exit $?
   2513 fi
   2514 
   2515 
   2516 # func_mode_execute arg...
   2517 func_mode_execute ()
   2518 {
   2519     $opt_debug
   2520     # The first argument is the command name.
   2521     cmd="$nonopt"
   2522     test -z "$cmd" && \
   2523       func_fatal_help "you must specify a COMMAND"
   2524 
   2525     # Handle -dlopen flags immediately.
   2526     for file in $opt_dlopen; do
   2527       test -f "$file" \
   2528 	|| func_fatal_help "\`$file' is not a file"
   2529 
   2530       dir=
   2531       case $file in
   2532       *.la)
   2533 	func_resolve_sysroot "$file"
   2534 	file=$func_resolve_sysroot_result
   2535 
   2536 	# Check to see that this really is a libtool archive.
   2537 	func_lalib_unsafe_p "$file" \
   2538 	  || func_fatal_help "\`$lib' is not a valid libtool archive"
   2539 
   2540 	# Read the libtool library.
   2541 	dlname=
   2542 	library_names=
   2543 	func_source "$file"
   2544 
   2545 	# Skip this library if it cannot be dlopened.
   2546 	if test -z "$dlname"; then
   2547 	  # Warn if it was a shared library.
   2548 	  test -n "$library_names" && \
   2549 	    func_warning "\`$file' was not linked with \`-export-dynamic'"
   2550 	  continue
   2551 	fi
   2552 
   2553 	func_dirname "$file" "" "."
   2554 	dir="$func_dirname_result"
   2555 
   2556 	if test -f "$dir/$objdir/$dlname"; then
   2557 	  func_append dir "/$objdir"
   2558 	else
   2559 	  if test ! -f "$dir/$dlname"; then
   2560 	    func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
   2561 	  fi
   2562 	fi
   2563 	;;
   2564 
   2565       *.lo)
   2566 	# Just add the directory containing the .lo file.
   2567 	func_dirname "$file" "" "."
   2568 	dir="$func_dirname_result"
   2569 	;;
   2570 
   2571       *)
   2572 	func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
   2573 	continue
   2574 	;;
   2575       esac
   2576 
   2577       # Get the absolute pathname.
   2578       absdir=`cd "$dir" && pwd`
   2579       test -n "$absdir" && dir="$absdir"
   2580 
   2581       # Now add the directory to shlibpath_var.
   2582       if eval "test -z \"\$$shlibpath_var\""; then
   2583 	eval "$shlibpath_var=\"\$dir\""
   2584       else
   2585 	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
   2586       fi
   2587     done
   2588 
   2589     # This variable tells wrapper scripts just to set shlibpath_var
   2590     # rather than running their programs.
   2591     libtool_execute_magic="$magic"
   2592 
   2593     # Check if any of the arguments is a wrapper script.
   2594     args=
   2595     for file
   2596     do
   2597       case $file in
   2598       -* | *.la | *.lo ) ;;
   2599       *)
   2600 	# Do a test to see if this is really a libtool program.
   2601 	if func_ltwrapper_script_p "$file"; then
   2602 	  func_source "$file"
   2603 	  # Transform arg to wrapped name.
   2604 	  file="$progdir/$program"
   2605 	elif func_ltwrapper_executable_p "$file"; then
   2606 	  func_ltwrapper_scriptname "$file"
   2607 	  func_source "$func_ltwrapper_scriptname_result"
   2608 	  # Transform arg to wrapped name.
   2609 	  file="$progdir/$program"
   2610 	fi
   2611 	;;
   2612       esac
   2613       # Quote arguments (to preserve shell metacharacters).
   2614       func_append_quoted args "$file"
   2615     done
   2616 
   2617     if test "X$opt_dry_run" = Xfalse; then
   2618       if test -n "$shlibpath_var"; then
   2619 	# Export the shlibpath_var.
   2620 	eval "export $shlibpath_var"
   2621       fi
   2622 
   2623       # Restore saved environment variables
   2624       for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
   2625       do
   2626 	eval "if test \"\${save_$lt_var+set}\" = set; then
   2627                 $lt_var=\$save_$lt_var; export $lt_var
   2628 	      else
   2629 		$lt_unset $lt_var
   2630 	      fi"
   2631       done
   2632 
   2633       # Now prepare to actually exec the command.
   2634       exec_cmd="\$cmd$args"
   2635     else
   2636       # Display what would be done.
   2637       if test -n "$shlibpath_var"; then
   2638 	eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
   2639 	echo "export $shlibpath_var"
   2640       fi
   2641       $ECHO "$cmd$args"
   2642       exit $EXIT_SUCCESS
   2643     fi
   2644 }
   2645 
   2646 test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
   2647 
   2648 
   2649 # func_mode_finish arg...
   2650 func_mode_finish ()
   2651 {
   2652     $opt_debug
   2653     libs=
   2654     libdirs=
   2655     admincmds=
   2656 
   2657     for opt in "$nonopt" ${1+"$@"}
   2658     do
   2659       if test -d "$opt"; then
   2660 	func_append libdirs " $opt"
   2661 
   2662       elif test -f "$opt"; then
   2663 	if func_lalib_unsafe_p "$opt"; then
   2664 	  func_append libs " $opt"
   2665 	else
   2666 	  func_warning "\`$opt' is not a valid libtool archive"
   2667 	fi
   2668 
   2669       else
   2670 	func_fatal_error "invalid argument \`$opt'"
   2671       fi
   2672     done
   2673 
   2674     if test -n "$libs"; then
   2675       if test -n "$lt_sysroot"; then
   2676         sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
   2677         sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
   2678       else
   2679         sysroot_cmd=
   2680       fi
   2681 
   2682       # Remove sysroot references
   2683       if $opt_dry_run; then
   2684         for lib in $libs; do
   2685           echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
   2686         done
   2687       else
   2688         tmpdir=`func_mktempdir`
   2689         for lib in $libs; do
   2690 	  sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
   2691 	    > $tmpdir/tmp-la
   2692 	  mv -f $tmpdir/tmp-la $lib
   2693 	done
   2694         ${RM}r "$tmpdir"
   2695       fi
   2696     fi
   2697 
   2698     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
   2699       for libdir in $libdirs; do
   2700 	if test -n "$finish_cmds"; then
   2701 	  # Do each command in the finish commands.
   2702 	  func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
   2703 '"$cmd"'"'
   2704 	fi
   2705 	if test -n "$finish_eval"; then
   2706 	  # Do the single finish_eval.
   2707 	  eval cmds=\"$finish_eval\"
   2708 	  $opt_dry_run || eval "$cmds" || func_append admincmds "
   2709        $cmds"
   2710 	fi
   2711       done
   2712     fi
   2713 
   2714     # Exit here if they wanted silent mode.
   2715     $opt_silent && exit $EXIT_SUCCESS
   2716 
   2717     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
   2718       echo "----------------------------------------------------------------------"
   2719       echo "Libraries have been installed in:"
   2720       for libdir in $libdirs; do
   2721 	$ECHO "   $libdir"
   2722       done
   2723       echo
   2724       echo "If you ever happen to want to link against installed libraries"
   2725       echo "in a given directory, LIBDIR, you must either use libtool, and"
   2726       echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
   2727       echo "flag during linking and do at least one of the following:"
   2728       if test -n "$shlibpath_var"; then
   2729 	echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
   2730 	echo "     during execution"
   2731       fi
   2732       if test -n "$runpath_var"; then
   2733 	echo "   - add LIBDIR to the \`$runpath_var' environment variable"
   2734 	echo "     during linking"
   2735       fi
   2736       if test -n "$hardcode_libdir_flag_spec"; then
   2737 	libdir=LIBDIR
   2738 	eval flag=\"$hardcode_libdir_flag_spec\"
   2739 
   2740 	$ECHO "   - use the \`$flag' linker flag"
   2741       fi
   2742       if test -n "$admincmds"; then
   2743 	$ECHO "   - have your system administrator run these commands:$admincmds"
   2744       fi
   2745       if test -f /etc/ld.so.conf; then
   2746 	echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
   2747       fi
   2748       echo
   2749 
   2750       echo "See any operating system documentation about shared libraries for"
   2751       case $host in
   2752 	solaris2.[6789]|solaris2.1[0-9])
   2753 	  echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
   2754 	  echo "pages."
   2755 	  ;;
   2756 	*)
   2757 	  echo "more information, such as the ld(1) and ld.so(8) manual pages."
   2758 	  ;;
   2759       esac
   2760       echo "----------------------------------------------------------------------"
   2761     fi
   2762     exit $EXIT_SUCCESS
   2763 }
   2764 
   2765 test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
   2766 
   2767 
   2768 # func_mode_install arg...
   2769 func_mode_install ()
   2770 {
   2771     $opt_debug
   2772     # There may be an optional sh(1) argument at the beginning of
   2773     # install_prog (especially on Windows NT).
   2774     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
   2775        # Allow the use of GNU shtool's install command.
   2776        case $nonopt in *shtool*) :;; *) false;; esac; then
   2777       # Aesthetically quote it.
   2778       func_quote_for_eval "$nonopt"
   2779       install_prog="$func_quote_for_eval_result "
   2780       arg=$1
   2781       shift
   2782     else
   2783       install_prog=
   2784       arg=$nonopt
   2785     fi
   2786 
   2787     # The real first argument should be the name of the installation program.
   2788     # Aesthetically quote it.
   2789     func_quote_for_eval "$arg"
   2790     func_append install_prog "$func_quote_for_eval_result"
   2791     install_shared_prog=$install_prog
   2792     case " $install_prog " in
   2793       *[\\\ /]cp\ *) install_cp=: ;;
   2794       *) install_cp=false ;;
   2795     esac
   2796 
   2797     # We need to accept at least all the BSD install flags.
   2798     dest=
   2799     files=
   2800     opts=
   2801     prev=
   2802     install_type=
   2803     isdir=no
   2804     stripme=
   2805     no_mode=:
   2806     for arg
   2807     do
   2808       arg2=
   2809       if test -n "$dest"; then
   2810 	func_append files " $dest"
   2811 	dest=$arg
   2812 	continue
   2813       fi
   2814 
   2815       case $arg in
   2816       -d) isdir=yes ;;
   2817       -f)
   2818 	if $install_cp; then :; else
   2819 	  prev=$arg
   2820 	fi
   2821 	;;
   2822       -g | -m | -o)
   2823 	prev=$arg
   2824 	;;
   2825       -s)
   2826 	stripme=" -s"
   2827 	continue
   2828 	;;
   2829       -*)
   2830 	;;
   2831       *)
   2832 	# If the previous option needed an argument, then skip it.
   2833 	if test -n "$prev"; then
   2834 	  if test "x$prev" = x-m && test -n "$install_override_mode"; then
   2835 	    arg2=$install_override_mode
   2836 	    no_mode=false
   2837 	  fi
   2838 	  prev=
   2839 	else
   2840 	  dest=$arg
   2841 	  continue
   2842 	fi
   2843 	;;
   2844       esac
   2845 
   2846       # Aesthetically quote the argument.
   2847       func_quote_for_eval "$arg"
   2848       func_append install_prog " $func_quote_for_eval_result"
   2849       if test -n "$arg2"; then
   2850 	func_quote_for_eval "$arg2"
   2851       fi
   2852       func_append install_shared_prog " $func_quote_for_eval_result"
   2853     done
   2854 
   2855     test -z "$install_prog" && \
   2856       func_fatal_help "you must specify an install program"
   2857 
   2858     test -n "$prev" && \
   2859       func_fatal_help "the \`$prev' option requires an argument"
   2860 
   2861     if test -n "$install_override_mode" && $no_mode; then
   2862       if $install_cp; then :; else
   2863 	func_quote_for_eval "$install_override_mode"
   2864 	func_append install_shared_prog " -m $func_quote_for_eval_result"
   2865       fi
   2866     fi
   2867 
   2868     if test -z "$files"; then
   2869       if test -z "$dest"; then
   2870 	func_fatal_help "no file or destination specified"
   2871       else
   2872 	func_fatal_help "you must specify a destination"
   2873       fi
   2874     fi
   2875 
   2876     # Strip any trailing slash from the destination.
   2877     func_stripname '' '/' "$dest"
   2878     dest=$func_stripname_result
   2879 
   2880     # Check to see that the destination is a directory.
   2881     test -d "$dest" && isdir=yes
   2882     if test "$isdir" = yes; then
   2883       destdir="$dest"
   2884       destname=
   2885     else
   2886       func_dirname_and_basename "$dest" "" "."
   2887       destdir="$func_dirname_result"
   2888       destname="$func_basename_result"
   2889 
   2890       # Not a directory, so check to see that there is only one file specified.
   2891       set dummy $files; shift
   2892       test "$#" -gt 1 && \
   2893 	func_fatal_help "\`$dest' is not a directory"
   2894     fi
   2895     case $destdir in
   2896     [\\/]* | [A-Za-z]:[\\/]*) ;;
   2897     *)
   2898       for file in $files; do
   2899 	case $file in
   2900 	*.lo) ;;
   2901 	*)
   2902 	  func_fatal_help "\`$destdir' must be an absolute directory name"
   2903 	  ;;
   2904 	esac
   2905       done
   2906       ;;
   2907     esac
   2908 
   2909     # This variable tells wrapper scripts just to set variables rather
   2910     # than running their programs.
   2911     libtool_install_magic="$magic"
   2912 
   2913     staticlibs=
   2914     future_libdirs=
   2915     current_libdirs=
   2916     for file in $files; do
   2917 
   2918       # Do each installation.
   2919       case $file in
   2920       *.$libext)
   2921 	# Do the static libraries later.
   2922 	func_append staticlibs " $file"
   2923 	;;
   2924 
   2925       *.la)
   2926 	func_resolve_sysroot "$file"
   2927 	file=$func_resolve_sysroot_result
   2928 
   2929 	# Check to see that this really is a libtool archive.
   2930 	func_lalib_unsafe_p "$file" \
   2931 	  || func_fatal_help "\`$file' is not a valid libtool archive"
   2932 
   2933 	library_names=
   2934 	old_library=
   2935 	relink_command=
   2936 	func_source "$file"
   2937 
   2938 	# Add the libdir to current_libdirs if it is the destination.
   2939 	if test "X$destdir" = "X$libdir"; then
   2940 	  case "$current_libdirs " in
   2941 	  *" $libdir "*) ;;
   2942 	  *) func_append current_libdirs " $libdir" ;;
   2943 	  esac
   2944 	else
   2945 	  # Note the libdir as a future libdir.
   2946 	  case "$future_libdirs " in
   2947 	  *" $libdir "*) ;;
   2948 	  *) func_append future_libdirs " $libdir" ;;
   2949 	  esac
   2950 	fi
   2951 
   2952 	func_dirname "$file" "/" ""
   2953 	dir="$func_dirname_result"
   2954 	func_append dir "$objdir"
   2955 
   2956 	if test -n "$relink_command"; then
   2957 	  # Determine the prefix the user has applied to our future dir.
   2958 	  inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
   2959 
   2960 	  # Don't allow the user to place us outside of our expected
   2961 	  # location b/c this prevents finding dependent libraries that
   2962 	  # are installed to the same prefix.
   2963 	  # At present, this check doesn't affect windows .dll's that
   2964 	  # are installed into $libdir/../bin (currently, that works fine)
   2965 	  # but it's something to keep an eye on.
   2966 	  test "$inst_prefix_dir" = "$destdir" && \
   2967 	    func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
   2968 
   2969 	  if test -n "$inst_prefix_dir"; then
   2970 	    # Stick the inst_prefix_dir data into the link command.
   2971 	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
   2972 	  else
   2973 	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
   2974 	  fi
   2975 
   2976 	  func_warning "relinking \`$file'"
   2977 	  func_show_eval "$relink_command" \
   2978 	    'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
   2979 	fi
   2980 
   2981 	# See the names of the shared library.
   2982 	set dummy $library_names; shift
   2983 	if test -n "$1"; then
   2984 	  realname="$1"
   2985 	  shift
   2986 
   2987 	  srcname="$realname"
   2988 	  test -n "$relink_command" && srcname="$realname"T
   2989 
   2990 	  # Install the shared library and build the symlinks.
   2991 	  func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
   2992 	      'exit $?'
   2993 	  tstripme="$stripme"
   2994 	  case $host_os in
   2995 	  cygwin* | mingw* | pw32* | cegcc*)
   2996 	    case $realname in
   2997 	    *.dll.a)
   2998 	      tstripme=""
   2999 	      ;;
   3000 	    esac
   3001 	    ;;
   3002 	  esac
   3003 	  if test -n "$tstripme" && test -n "$striplib"; then
   3004 	    func_show_eval "$striplib $destdir/$realname" 'exit $?'
   3005 	  fi
   3006 
   3007 	  if test "$#" -gt 0; then
   3008 	    # Delete the old symlinks, and create new ones.
   3009 	    # Try `ln -sf' first, because the `ln' binary might depend on
   3010 	    # the symlink we replace!  Solaris /bin/ln does not understand -f,
   3011 	    # so we also need to try rm && ln -s.
   3012 	    for linkname
   3013 	    do
   3014 	      test "$linkname" != "$realname" \
   3015 		&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
   3016 	    done
   3017 	  fi
   3018 
   3019 	  # Do each command in the postinstall commands.
   3020 	  lib="$destdir/$realname"
   3021 	  func_execute_cmds "$postinstall_cmds" 'exit $?'
   3022 	fi
   3023 
   3024 	# Install the pseudo-library for information purposes.
   3025 	func_basename "$file"
   3026 	name="$func_basename_result"
   3027 	instname="$dir/$name"i
   3028 	func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
   3029 
   3030 	# Maybe install the static library, too.
   3031 	test -n "$old_library" && func_append staticlibs " $dir/$old_library"
   3032 	;;
   3033 
   3034       *.lo)
   3035 	# Install (i.e. copy) a libtool object.
   3036 
   3037 	# Figure out destination file name, if it wasn't already specified.
   3038 	if test -n "$destname"; then
   3039 	  destfile="$destdir/$destname"
   3040 	else
   3041 	  func_basename "$file"
   3042 	  destfile="$func_basename_result"
   3043 	  destfile="$destdir/$destfile"
   3044 	fi
   3045 
   3046 	# Deduce the name of the destination old-style object file.
   3047 	case $destfile in
   3048 	*.lo)
   3049 	  func_lo2o "$destfile"
   3050 	  staticdest=$func_lo2o_result
   3051 	  ;;
   3052 	*.$objext)
   3053 	  staticdest="$destfile"
   3054 	  destfile=
   3055 	  ;;
   3056 	*)
   3057 	  func_fatal_help "cannot copy a libtool object to \`$destfile'"
   3058 	  ;;
   3059 	esac
   3060 
   3061 	# Install the libtool object if requested.
   3062 	test -n "$destfile" && \
   3063 	  func_show_eval "$install_prog $file $destfile" 'exit $?'
   3064 
   3065 	# Install the old object if enabled.
   3066 	if test "$build_old_libs" = yes; then
   3067 	  # Deduce the name of the old-style object file.
   3068 	  func_lo2o "$file"
   3069 	  staticobj=$func_lo2o_result
   3070 	  func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
   3071 	fi
   3072 	exit $EXIT_SUCCESS
   3073 	;;
   3074 
   3075       *)
   3076 	# Figure out destination file name, if it wasn't already specified.
   3077 	if test -n "$destname"; then
   3078 	  destfile="$destdir/$destname"
   3079 	else
   3080 	  func_basename "$file"
   3081 	  destfile="$func_basename_result"
   3082 	  destfile="$destdir/$destfile"
   3083 	fi
   3084 
   3085 	# If the file is missing, and there is a .exe on the end, strip it
   3086 	# because it is most likely a libtool script we actually want to
   3087 	# install
   3088 	stripped_ext=""
   3089 	case $file in
   3090 	  *.exe)
   3091 	    if test ! -f "$file"; then
   3092 	      func_stripname '' '.exe' "$file"
   3093 	      file=$func_stripname_result
   3094 	      stripped_ext=".exe"
   3095 	    fi
   3096 	    ;;
   3097 	esac
   3098 
   3099 	# Do a test to see if this is really a libtool program.
   3100 	case $host in
   3101 	*cygwin* | *mingw*)
   3102 	    if func_ltwrapper_executable_p "$file"; then
   3103 	      func_ltwrapper_scriptname "$file"
   3104 	      wrapper=$func_ltwrapper_scriptname_result
   3105 	    else
   3106 	      func_stripname '' '.exe' "$file"
   3107 	      wrapper=$func_stripname_result
   3108 	    fi
   3109 	    ;;
   3110 	*)
   3111 	    wrapper=$file
   3112 	    ;;
   3113 	esac
   3114 	if func_ltwrapper_script_p "$wrapper"; then
   3115 	  notinst_deplibs=
   3116 	  relink_command=
   3117 
   3118 	  func_source "$wrapper"
   3119 
   3120 	  # Check the variables that should have been set.
   3121 	  test -z "$generated_by_libtool_version" && \
   3122 	    func_fatal_error "invalid libtool wrapper script \`$wrapper'"
   3123 
   3124 	  finalize=yes
   3125 	  for lib in $notinst_deplibs; do
   3126 	    # Check to see that each library is installed.
   3127 	    libdir=
   3128 	    if test -f "$lib"; then
   3129 	      func_source "$lib"
   3130 	    fi
   3131 	    libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
   3132 	    if test -n "$libdir" && test ! -f "$libfile"; then
   3133 	      func_warning "\`$lib' has not been installed in \`$libdir'"
   3134 	      finalize=no
   3135 	    fi
   3136 	  done
   3137 
   3138 	  relink_command=
   3139 	  func_source "$wrapper"
   3140 
   3141 	  outputname=
   3142 	  if test "$fast_install" = no && test -n "$relink_command"; then
   3143 	    $opt_dry_run || {
   3144 	      if test "$finalize" = yes; then
   3145 	        tmpdir=`func_mktempdir`
   3146 		func_basename "$file$stripped_ext"
   3147 		file="$func_basename_result"
   3148 	        outputname="$tmpdir/$file"
   3149 	        # Replace the output file specification.
   3150 	        relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
   3151 
   3152 	        $opt_silent || {
   3153 	          func_quote_for_expand "$relink_command"
   3154 		  eval "func_echo $func_quote_for_expand_result"
   3155 	        }
   3156 	        if eval "$relink_command"; then :
   3157 	          else
   3158 		  func_error "error: relink \`$file' with the above command before installing it"
   3159 		  $opt_dry_run || ${RM}r "$tmpdir"
   3160 		  continue
   3161 	        fi
   3162 	        file="$outputname"
   3163 	      else
   3164 	        func_warning "cannot relink \`$file'"
   3165 	      fi
   3166 	    }
   3167 	  else
   3168 	    # Install the binary that we compiled earlier.
   3169 	    file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
   3170 	  fi
   3171 	fi
   3172 
   3173 	# remove .exe since cygwin /usr/bin/install will append another
   3174 	# one anyway
   3175 	case $install_prog,$host in
   3176 	*/usr/bin/install*,*cygwin*)
   3177 	  case $file:$destfile in
   3178 	  *.exe:*.exe)
   3179 	    # this is ok
   3180 	    ;;
   3181 	  *.exe:*)
   3182 	    destfile=$destfile.exe
   3183 	    ;;
   3184 	  *:*.exe)
   3185 	    func_stripname '' '.exe' "$destfile"
   3186 	    destfile=$func_stripname_result
   3187 	    ;;
   3188 	  esac
   3189 	  ;;
   3190 	esac
   3191 	func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
   3192 	$opt_dry_run || if test -n "$outputname"; then
   3193 	  ${RM}r "$tmpdir"
   3194 	fi
   3195 	;;
   3196       esac
   3197     done
   3198 
   3199     for file in $staticlibs; do
   3200       func_basename "$file"
   3201       name="$func_basename_result"
   3202 
   3203       # Set up the ranlib parameters.
   3204       oldlib="$destdir/$name"
   3205       func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
   3206       tool_oldlib=$func_to_tool_file_result
   3207 
   3208       func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
   3209 
   3210       if test -n "$stripme" && test -n "$old_striplib"; then
   3211 	func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
   3212       fi
   3213 
   3214       # Do each command in the postinstall commands.
   3215       func_execute_cmds "$old_postinstall_cmds" 'exit $?'
   3216     done
   3217 
   3218     test -n "$future_libdirs" && \
   3219       func_warning "remember to run \`$progname --finish$future_libdirs'"
   3220 
   3221     if test -n "$current_libdirs"; then
   3222       # Maybe just do a dry run.
   3223       $opt_dry_run && current_libdirs=" -n$current_libdirs"
   3224       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
   3225     else
   3226       exit $EXIT_SUCCESS
   3227     fi
   3228 }
   3229 
   3230 test "$opt_mode" = install && func_mode_install ${1+"$@"}
   3231 
   3232 
   3233 # func_generate_dlsyms outputname originator pic_p
   3234 # Extract symbols from dlprefiles and create ${outputname}S.o with
   3235 # a dlpreopen symbol table.
   3236 func_generate_dlsyms ()
   3237 {
   3238     $opt_debug
   3239     my_outputname="$1"
   3240     my_originator="$2"
   3241     my_pic_p="${3-no}"
   3242     my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
   3243     my_dlsyms=
   3244 
   3245     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
   3246       if test -n "$NM" && test -n "$global_symbol_pipe"; then
   3247 	my_dlsyms="${my_outputname}S.c"
   3248       else
   3249 	func_error "not configured to extract global symbols from dlpreopened files"
   3250       fi
   3251     fi
   3252 
   3253     if test -n "$my_dlsyms"; then
   3254       case $my_dlsyms in
   3255       "") ;;
   3256       *.c)
   3257 	# Discover the nlist of each of the dlfiles.
   3258 	nlist="$output_objdir/${my_outputname}.nm"
   3259 
   3260 	func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
   3261 
   3262 	# Parse the name list into a source file.
   3263 	func_verbose "creating $output_objdir/$my_dlsyms"
   3264 
   3265 	$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
   3266 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
   3267 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
   3268 
   3269 #ifdef __cplusplus
   3270 extern \"C\" {
   3271 #endif
   3272 
   3273 #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
   3274 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
   3275 #endif
   3276 
   3277 /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
   3278 #if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
   3279 /* DATA imports from DLLs on WIN32 con't be const, because runtime
   3280    relocations are performed -- see ld's documentation on pseudo-relocs.  */
   3281 # define LT_DLSYM_CONST
   3282 #elif defined(__osf__)
   3283 /* This system does not cope well with relocations in const data.  */
   3284 # define LT_DLSYM_CONST
   3285 #else
   3286 # define LT_DLSYM_CONST const
   3287 #endif
   3288 
   3289 /* External symbol declarations for the compiler. */\
   3290 "
   3291 
   3292 	if test "$dlself" = yes; then
   3293 	  func_verbose "generating symbol list for \`$output'"
   3294 
   3295 	  $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
   3296 
   3297 	  # Add our own program objects to the symbol list.
   3298 	  progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
   3299 	  for progfile in $progfiles; do
   3300 	    func_to_tool_file "$progfile" func_convert_file_msys_to_w32
   3301 	    func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
   3302 	    $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
   3303 	  done
   3304 
   3305 	  if test -n "$exclude_expsyms"; then
   3306 	    $opt_dry_run || {
   3307 	      eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
   3308 	      eval '$MV "$nlist"T "$nlist"'
   3309 	    }
   3310 	  fi
   3311 
   3312 	  if test -n "$export_symbols_regex"; then
   3313 	    $opt_dry_run || {
   3314 	      eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
   3315 	      eval '$MV "$nlist"T "$nlist"'
   3316 	    }
   3317 	  fi
   3318 
   3319 	  # Prepare the list of exported symbols
   3320 	  if test -z "$export_symbols"; then
   3321 	    export_symbols="$output_objdir/$outputname.exp"
   3322 	    $opt_dry_run || {
   3323 	      $RM $export_symbols
   3324 	      eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
   3325 	      case $host in
   3326 	      *cygwin* | *mingw* | *cegcc* )
   3327                 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
   3328                 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
   3329 	        ;;
   3330 	      esac
   3331 	    }
   3332 	  else
   3333 	    $opt_dry_run || {
   3334 	      eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
   3335 	      eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
   3336 	      eval '$MV "$nlist"T "$nlist"'
   3337 	      case $host in
   3338 	        *cygwin* | *mingw* | *cegcc* )
   3339 	          eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
   3340 	          eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
   3341 	          ;;
   3342 	      esac
   3343 	    }
   3344 	  fi
   3345 	fi
   3346 
   3347 	for dlprefile in $dlprefiles; do
   3348 	  func_verbose "extracting global C symbols from \`$dlprefile'"
   3349 	  func_basename "$dlprefile"
   3350 	  name="$func_basename_result"
   3351           case $host in
   3352 	    *cygwin* | *mingw* | *cegcc* )
   3353 	      # if an import library, we need to obtain dlname
   3354 	      if func_win32_import_lib_p "$dlprefile"; then
   3355 	        func_tr_sh "$dlprefile"
   3356 	        eval "curr_lafile=\$libfile_$func_tr_sh_result"
   3357 	        dlprefile_dlbasename=""
   3358 	        if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
   3359 	          # Use subshell, to avoid clobbering current variable values
   3360 	          dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
   3361 	          if test -n "$dlprefile_dlname" ; then
   3362 	            func_basename "$dlprefile_dlname"
   3363 	            dlprefile_dlbasename="$func_basename_result"
   3364 	          else
   3365 	            # no lafile. user explicitly requested -dlpreopen <import library>.
   3366 	            $sharedlib_from_linklib_cmd "$dlprefile"
   3367 	            dlprefile_dlbasename=$sharedlib_from_linklib_result
   3368 	          fi
   3369 	        fi
   3370 	        $opt_dry_run || {
   3371 	          if test -n "$dlprefile_dlbasename" ; then
   3372 	            eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
   3373 	          else
   3374 	            func_warning "Could not compute DLL name from $name"
   3375 	            eval '$ECHO ": $name " >> "$nlist"'
   3376 	          fi
   3377 	          func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
   3378 	          eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
   3379 	            $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
   3380 	        }
   3381 	      else # not an import lib
   3382 	        $opt_dry_run || {
   3383 	          eval '$ECHO ": $name " >> "$nlist"'
   3384 	          func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
   3385 	          eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
   3386 	        }
   3387 	      fi
   3388 	    ;;
   3389 	    *)
   3390 	      $opt_dry_run || {
   3391 	        eval '$ECHO ": $name " >> "$nlist"'
   3392 	        func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
   3393 	        eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
   3394 	      }
   3395 	    ;;
   3396           esac
   3397 	done
   3398 
   3399 	$opt_dry_run || {
   3400 	  # Make sure we have at least an empty file.
   3401 	  test -f "$nlist" || : > "$nlist"
   3402 
   3403 	  if test -n "$exclude_expsyms"; then
   3404 	    $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
   3405 	    $MV "$nlist"T "$nlist"
   3406 	  fi
   3407 
   3408 	  # Try sorting and uniquifying the output.
   3409 	  if $GREP -v "^: " < "$nlist" |
   3410 	      if sort -k 3 </dev/null >/dev/null 2>&1; then
   3411 		sort -k 3
   3412 	      else
   3413 		sort +2
   3414 	      fi |
   3415 	      uniq > "$nlist"S; then
   3416 	    :
   3417 	  else
   3418 	    $GREP -v "^: " < "$nlist" > "$nlist"S
   3419 	  fi
   3420 
   3421 	  if test -f "$nlist"S; then
   3422 	    eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
   3423 	  else
   3424 	    echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
   3425 	  fi
   3426 
   3427 	  echo >> "$output_objdir/$my_dlsyms" "\
   3428 
   3429 /* The mapping between symbol names and symbols.  */
   3430 typedef struct {
   3431   const char *name;
   3432   void *address;
   3433 } lt_dlsymlist;
   3434 extern LT_DLSYM_CONST lt_dlsymlist
   3435 lt_${my_prefix}_LTX_preloaded_symbols[];
   3436 LT_DLSYM_CONST lt_dlsymlist
   3437 lt_${my_prefix}_LTX_preloaded_symbols[] =
   3438 {\
   3439   { \"$my_originator\", (void *) 0 },"
   3440 
   3441 	  case $need_lib_prefix in
   3442 	  no)
   3443 	    eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
   3444 	    ;;
   3445 	  *)
   3446 	    eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
   3447 	    ;;
   3448 	  esac
   3449 	  echo >> "$output_objdir/$my_dlsyms" "\
   3450   {0, (void *) 0}
   3451 };
   3452 
   3453 /* This works around a problem in FreeBSD linker */
   3454 #ifdef FREEBSD_WORKAROUND
   3455 static const void *lt_preloaded_setup() {
   3456   return lt_${my_prefix}_LTX_preloaded_symbols;
   3457 }
   3458 #endif
   3459 
   3460 #ifdef __cplusplus
   3461 }
   3462 #endif\
   3463 "
   3464 	} # !$opt_dry_run
   3465 
   3466 	pic_flag_for_symtable=
   3467 	case "$compile_command " in
   3468 	*" -static "*) ;;
   3469 	*)
   3470 	  case $host in
   3471 	  # compiling the symbol table file with pic_flag works around
   3472 	  # a FreeBSD bug that causes programs to crash when -lm is
   3473 	  # linked before any other PIC object.  But we must not use
   3474 	  # pic_flag when linking with -static.  The problem exists in
   3475 	  # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
   3476 	  *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
   3477 	    pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
   3478 	  *-*-hpux*)
   3479 	    pic_flag_for_symtable=" $pic_flag"  ;;
   3480 	  *)
   3481 	    if test "X$my_pic_p" != Xno; then
   3482 	      pic_flag_for_symtable=" $pic_flag"
   3483 	    fi
   3484 	    ;;
   3485 	  esac
   3486 	  ;;
   3487 	esac
   3488 	symtab_cflags=
   3489 	for arg in $LTCFLAGS; do
   3490 	  case $arg in
   3491 	  -pie | -fpie | -fPIE) ;;
   3492 	  *) func_append symtab_cflags " $arg" ;;
   3493 	  esac
   3494 	done
   3495 
   3496 	# Now compile the dynamic symbol file.
   3497 	func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
   3498 
   3499 	# Clean up the generated files.
   3500 	func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
   3501 
   3502 	# Transform the symbol file into the correct name.
   3503 	symfileobj="$output_objdir/${my_outputname}S.$objext"
   3504 	case $host in
   3505 	*cygwin* | *mingw* | *cegcc* )
   3506 	  if test -f "$output_objdir/$my_outputname.def"; then
   3507 	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
   3508 	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
   3509 	  else
   3510 	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
   3511 	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
   3512 	  fi
   3513 	  ;;
   3514 	*)
   3515 	  compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
   3516 	  finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
   3517 	  ;;
   3518 	esac
   3519 	;;
   3520       *)
   3521 	func_fatal_error "unknown suffix for \`$my_dlsyms'"
   3522 	;;
   3523       esac
   3524     else
   3525       # We keep going just in case the user didn't refer to
   3526       # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
   3527       # really was required.
   3528 
   3529       # Nullify the symbol file.
   3530       compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
   3531       finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
   3532     fi
   3533 }
   3534 
   3535 # func_win32_libid arg
   3536 # return the library type of file 'arg'
   3537 #
   3538 # Need a lot of goo to handle *both* DLLs and import libs
   3539 # Has to be a shell function in order to 'eat' the argument
   3540 # that is supplied when $file_magic_command is called.
   3541 # Despite the name, also deal with 64 bit binaries.
   3542 func_win32_libid ()
   3543 {
   3544   $opt_debug
   3545   win32_libid_type="unknown"
   3546   win32_fileres=`file -L $1 2>/dev/null`
   3547   case $win32_fileres in
   3548   *ar\ archive\ import\ library*) # definitely import
   3549     win32_libid_type="x86 archive import"
   3550     ;;
   3551   *ar\ archive*) # could be an import, or static
   3552     # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
   3553     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
   3554        $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
   3555       func_to_tool_file "$1" func_convert_file_msys_to_w32
   3556       win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
   3557 	$SED -n -e '
   3558 	    1,100{
   3559 		/ I /{
   3560 		    s,.*,import,
   3561 		    p
   3562 		    q
   3563 		}
   3564 	    }'`
   3565       case $win32_nmres in
   3566       import*)  win32_libid_type="x86 archive import";;
   3567       *)        win32_libid_type="x86 archive static";;
   3568       esac
   3569     fi
   3570     ;;
   3571   *DLL*)
   3572     win32_libid_type="x86 DLL"
   3573     ;;
   3574   *executable*) # but shell scripts are "executable" too...
   3575     case $win32_fileres in
   3576     *MS\ Windows\ PE\ Intel*)
   3577       win32_libid_type="x86 DLL"
   3578       ;;
   3579     esac
   3580     ;;
   3581   esac
   3582   $ECHO "$win32_libid_type"
   3583 }
   3584 
   3585 # func_cygming_dll_for_implib ARG
   3586 #
   3587 # Platform-specific function to extract the
   3588 # name of the DLL associated with the specified
   3589 # import library ARG.
   3590 # Invoked by eval'ing the libtool variable
   3591 #    $sharedlib_from_linklib_cmd
   3592 # Result is available in the variable
   3593 #    $sharedlib_from_linklib_result
   3594 func_cygming_dll_for_implib ()
   3595 {
   3596   $opt_debug
   3597   sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
   3598 }
   3599 
   3600 # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
   3601 #
   3602 # The is the core of a fallback implementation of a
   3603 # platform-specific function to extract the name of the
   3604 # DLL associated with the specified import library LIBNAME.
   3605 #
   3606 # SECTION_NAME is either .idata$6 or .idata$7, depending
   3607 # on the platform and compiler that created the implib.
   3608 #
   3609 # Echos the name of the DLL associated with the
   3610 # specified import library.
   3611 func_cygming_dll_for_implib_fallback_core ()
   3612 {
   3613   $opt_debug
   3614   match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
   3615   $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
   3616     $SED '/^Contents of section '"$match_literal"':/{
   3617       # Place marker at beginning of archive member dllname section
   3618       s/.*/====MARK====/
   3619       p
   3620       d
   3621     }
   3622     # These lines can sometimes be longer than 43 characters, but
   3623     # are always uninteresting
   3624     /:[	 ]*file format pe[i]\{,1\}-/d
   3625     /^In archive [^:]*:/d
   3626     # Ensure marker is printed
   3627     /^====MARK====/p
   3628     # Remove all lines with less than 43 characters
   3629     /^.\{43\}/!d
   3630     # From remaining lines, remove first 43 characters
   3631     s/^.\{43\}//' |
   3632     $SED -n '
   3633       # Join marker and all lines until next marker into a single line
   3634       /^====MARK====/ b para
   3635       H
   3636       $ b para
   3637       b
   3638       :para
   3639       x
   3640       s/\n//g
   3641       # Remove the marker
   3642       s/^====MARK====//
   3643       # Remove trailing dots and whitespace
   3644       s/[\. \t]*$//
   3645       # Print
   3646       /./p' |
   3647     # we now have a list, one entry per line, of the stringified
   3648     # contents of the appropriate section of all members of the
   3649     # archive which possess that section. Heuristic: eliminate
   3650     # all those which have a first or second character that is
   3651     # a '.' (that is, objdump's representation of an unprintable
   3652     # character.) This should work for all archives with less than
   3653     # 0x302f exports -- but will fail for DLLs whose name actually
   3654     # begins with a literal '.' or a single character followed by
   3655     # a '.'.
   3656     #
   3657     # Of those that remain, print the first one.
   3658     $SED -e '/^\./d;/^.\./d;q'
   3659 }
   3660 
   3661 # func_cygming_gnu_implib_p ARG
   3662 # This predicate returns with zero status (TRUE) if
   3663 # ARG is a GNU/binutils-style import library. Returns
   3664 # with nonzero status (FALSE) otherwise.
   3665 func_cygming_gnu_implib_p ()
   3666 {
   3667   $opt_debug
   3668   func_to_tool_file "$1" func_convert_file_msys_to_w32
   3669   func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
   3670   test -n "$func_cygming_gnu_implib_tmp"
   3671 }
   3672 
   3673 # func_cygming_ms_implib_p ARG
   3674 # This predicate returns with zero status (TRUE) if
   3675 # ARG is an MS-style import library. Returns
   3676 # with nonzero status (FALSE) otherwise.
   3677 func_cygming_ms_implib_p ()
   3678 {
   3679   $opt_debug
   3680   func_to_tool_file "$1" func_convert_file_msys_to_w32
   3681   func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
   3682   test -n "$func_cygming_ms_implib_tmp"
   3683 }
   3684 
   3685 # func_cygming_dll_for_implib_fallback ARG
   3686 # Platform-specific function to extract the
   3687 # name of the DLL associated with the specified
   3688 # import library ARG.
   3689 #
   3690 # This fallback implementation is for use when $DLLTOOL
   3691 # does not support the --identify-strict option.
   3692 # Invoked by eval'ing the libtool variable
   3693 #    $sharedlib_from_linklib_cmd
   3694 # Result is available in the variable
   3695 #    $sharedlib_from_linklib_result
   3696 func_cygming_dll_for_implib_fallback ()
   3697 {
   3698   $opt_debug
   3699   if func_cygming_gnu_implib_p "$1" ; then
   3700     # binutils import library
   3701     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
   3702   elif func_cygming_ms_implib_p "$1" ; then
   3703     # ms-generated import library
   3704     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
   3705   else
   3706     # unknown
   3707     sharedlib_from_linklib_result=""
   3708   fi
   3709 }
   3710 
   3711 
   3712 # func_extract_an_archive dir oldlib
   3713 func_extract_an_archive ()
   3714 {
   3715     $opt_debug
   3716     f_ex_an_ar_dir="$1"; shift
   3717     f_ex_an_ar_oldlib="$1"
   3718     if test "$lock_old_archive_extraction" = yes; then
   3719       lockfile=$f_ex_an_ar_oldlib.lock
   3720       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
   3721 	func_echo "Waiting for $lockfile to be removed"
   3722 	sleep 2
   3723       done
   3724     fi
   3725     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
   3726 		   'stat=$?; rm -f "$lockfile"; exit $stat'
   3727     if test "$lock_old_archive_extraction" = yes; then
   3728       $opt_dry_run || rm -f "$lockfile"
   3729     fi
   3730     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
   3731      :
   3732     else
   3733       func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
   3734     fi
   3735 }
   3736 
   3737 
   3738 # func_extract_archives gentop oldlib ...
   3739 func_extract_archives ()
   3740 {
   3741     $opt_debug
   3742     my_gentop="$1"; shift
   3743     my_oldlibs=${1+"$@"}
   3744     my_oldobjs=""
   3745     my_xlib=""
   3746     my_xabs=""
   3747     my_xdir=""
   3748 
   3749     for my_xlib in $my_oldlibs; do
   3750       # Extract the objects.
   3751       case $my_xlib in
   3752 	[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
   3753 	*) my_xabs=`pwd`"/$my_xlib" ;;
   3754       esac
   3755       func_basename "$my_xlib"
   3756       my_xlib="$func_basename_result"
   3757       my_xlib_u=$my_xlib
   3758       while :; do
   3759         case " $extracted_archives " in
   3760 	*" $my_xlib_u "*)
   3761 	  func_arith $extracted_serial + 1
   3762 	  extracted_serial=$func_arith_result
   3763 	  my_xlib_u=lt$extracted_serial-$my_xlib ;;
   3764 	*) break ;;
   3765 	esac
   3766       done
   3767       extracted_archives="$extracted_archives $my_xlib_u"
   3768       my_xdir="$my_gentop/$my_xlib_u"
   3769 
   3770       func_mkdir_p "$my_xdir"
   3771 
   3772       case $host in
   3773       *-darwin*)
   3774 	func_verbose "Extracting $my_xabs"
   3775 	# Do not bother doing anything if just a dry run
   3776 	$opt_dry_run || {
   3777 	  darwin_orig_dir=`pwd`
   3778 	  cd $my_xdir || exit $?
   3779 	  darwin_archive=$my_xabs
   3780 	  darwin_curdir=`pwd`
   3781 	  darwin_base_archive=`basename "$darwin_archive"`
   3782 	  darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
   3783 	  if test -n "$darwin_arches"; then
   3784 	    darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
   3785 	    darwin_arch=
   3786 	    func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
   3787 	    for darwin_arch in  $darwin_arches ; do
   3788 	      func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
   3789 	      $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
   3790 	      cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
   3791 	      func_extract_an_archive "`pwd`" "${darwin_base_archive}"
   3792 	      cd "$darwin_curdir"
   3793 	      $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
   3794 	    done # $darwin_arches
   3795             ## Okay now we've a bunch of thin objects, gotta fatten them up :)
   3796 	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
   3797 	    darwin_file=
   3798 	    darwin_files=
   3799 	    for darwin_file in $darwin_filelist; do
   3800 	      darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
   3801 	      $LIPO -create -output "$darwin_file" $darwin_files
   3802 	    done # $darwin_filelist
   3803 	    $RM -rf unfat-$$
   3804 	    cd "$darwin_orig_dir"
   3805 	  else
   3806 	    cd $darwin_orig_dir
   3807 	    func_extract_an_archive "$my_xdir" "$my_xabs"
   3808 	  fi # $darwin_arches
   3809 	} # !$opt_dry_run
   3810 	;;
   3811       *)
   3812         func_extract_an_archive "$my_xdir" "$my_xabs"
   3813 	;;
   3814       esac
   3815       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
   3816     done
   3817 
   3818     func_extract_archives_result="$my_oldobjs"
   3819 }
   3820 
   3821 
   3822 # func_emit_wrapper [arg=no]
   3823 #
   3824 # Emit a libtool wrapper script on stdout.
   3825 # Don't directly open a file because we may want to
   3826 # incorporate the script contents within a cygwin/mingw
   3827 # wrapper executable.  Must ONLY be called from within
   3828 # func_mode_link because it depends on a number of variables
   3829 # set therein.
   3830 #
   3831 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
   3832 # variable will take.  If 'yes', then the emitted script
   3833 # will assume that the directory in which it is stored is
   3834 # the $objdir directory.  This is a cygwin/mingw-specific
   3835 # behavior.
   3836 func_emit_wrapper ()
   3837 {
   3838 	func_emit_wrapper_arg1=${1-no}
   3839 
   3840 	$ECHO "\
   3841 #! $SHELL
   3842 
   3843 # $output - temporary wrapper script for $objdir/$outputname
   3844 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
   3845 #
   3846 # The $output program cannot be directly executed until all the libtool
   3847 # libraries that it depends on are installed.
   3848 #
   3849 # This wrapper script should never be moved out of the build directory.
   3850 # If it is, it will not operate correctly.
   3851 
   3852 # Sed substitution that helps us do robust quoting.  It backslashifies
   3853 # metacharacters that are still active within double-quoted strings.
   3854 sed_quote_subst='$sed_quote_subst'
   3855 
   3856 # Be Bourne compatible
   3857 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
   3858   emulate sh
   3859   NULLCMD=:
   3860   # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
   3861   # is contrary to our usage.  Disable this feature.
   3862   alias -g '\${1+\"\$@\"}'='\"\$@\"'
   3863   setopt NO_GLOB_SUBST
   3864 else
   3865   case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
   3866 fi
   3867 BIN_SH=xpg4; export BIN_SH # for Tru64
   3868 DUALCASE=1; export DUALCASE # for MKS sh
   3869 
   3870 # The HP-UX ksh and POSIX shell print the target directory to stdout
   3871 # if CDPATH is set.
   3872 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
   3873 
   3874 relink_command=\"$relink_command\"
   3875 
   3876 # This environment variable determines our operation mode.
   3877 if test \"\$libtool_install_magic\" = \"$magic\"; then
   3878   # install mode needs the following variables:
   3879   generated_by_libtool_version='$macro_version'
   3880   notinst_deplibs='$notinst_deplibs'
   3881 else
   3882   # When we are sourced in execute mode, \$file and \$ECHO are already set.
   3883   if test \"\$libtool_execute_magic\" != \"$magic\"; then
   3884     file=\"\$0\""
   3885 
   3886     qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
   3887     $ECHO "\
   3888 
   3889 # A function that is used when there is no print builtin or printf.
   3890 func_fallback_echo ()
   3891 {
   3892   eval 'cat <<_LTECHO_EOF
   3893 \$1
   3894 _LTECHO_EOF'
   3895 }
   3896     ECHO=\"$qECHO\"
   3897   fi
   3898 
   3899 # Very basic option parsing. These options are (a) specific to
   3900 # the libtool wrapper, (b) are identical between the wrapper
   3901 # /script/ and the wrapper /executable/ which is used only on
   3902 # windows platforms, and (c) all begin with the string "--lt-"
   3903 # (application programs are unlikely to have options which match
   3904 # this pattern).
   3905 #
   3906 # There are only two supported options: --lt-debug and
   3907 # --lt-dump-script. There is, deliberately, no --lt-help.
   3908 #
   3909 # The first argument to this parsing function should be the
   3910 # script's $0 value, followed by "$@".
   3911 lt_option_debug=
   3912 func_parse_lt_options ()
   3913 {
   3914   lt_script_arg0=\$0
   3915   shift
   3916   for lt_opt
   3917   do
   3918     case \"\$lt_opt\" in
   3919     --lt-debug) lt_option_debug=1 ;;
   3920     --lt-dump-script)
   3921         lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
   3922         test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
   3923         lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
   3924         cat \"\$lt_dump_D/\$lt_dump_F\"
   3925         exit 0
   3926       ;;
   3927     --lt-*)
   3928         \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
   3929         exit 1
   3930       ;;
   3931     esac
   3932   done
   3933 
   3934   # Print the debug banner immediately:
   3935   if test -n \"\$lt_option_debug\"; then
   3936     echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
   3937   fi
   3938 }
   3939 
   3940 # Used when --lt-debug. Prints its arguments to stdout
   3941 # (redirection is the responsibility of the caller)
   3942 func_lt_dump_args ()
   3943 {
   3944   lt_dump_args_N=1;
   3945   for lt_arg
   3946   do
   3947     \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
   3948     lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
   3949   done
   3950 }
   3951 
   3952 # Core function for launching the target application
   3953 func_exec_program_core ()
   3954 {
   3955 "
   3956   case $host in
   3957   # Backslashes separate directories on plain windows
   3958   *-*-mingw | *-*-os2* | *-cegcc*)
   3959     $ECHO "\
   3960       if test -n \"\$lt_option_debug\"; then
   3961         \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
   3962         func_lt_dump_args \${1+\"\$@\"} 1>&2
   3963       fi
   3964       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
   3965 "
   3966     ;;
   3967 
   3968   *)
   3969     $ECHO "\
   3970       if test -n \"\$lt_option_debug\"; then
   3971         \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
   3972         func_lt_dump_args \${1+\"\$@\"} 1>&2
   3973       fi
   3974       exec \"\$progdir/\$program\" \${1+\"\$@\"}
   3975 "
   3976     ;;
   3977   esac
   3978   $ECHO "\
   3979       \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
   3980       exit 1
   3981 }
   3982 
   3983 # A function to encapsulate launching the target application
   3984 # Strips options in the --lt-* namespace from \$@ and
   3985 # launches target application with the remaining arguments.
   3986 func_exec_program ()
   3987 {
   3988   case \" \$* \" in
   3989   *\\ --lt-*)
   3990     for lt_wr_arg
   3991     do
   3992       case \$lt_wr_arg in
   3993       --lt-*) ;;
   3994       *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
   3995       esac
   3996       shift
   3997     done ;;
   3998   esac
   3999   func_exec_program_core \${1+\"\$@\"}
   4000 }
   4001 
   4002   # Parse options
   4003   func_parse_lt_options \"\$0\" \${1+\"\$@\"}
   4004 
   4005   # Find the directory that this script lives in.
   4006   thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
   4007   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
   4008 
   4009   # Follow symbolic links until we get to the real thisdir.
   4010   file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
   4011   while test -n \"\$file\"; do
   4012     destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
   4013 
   4014     # If there was a directory component, then change thisdir.
   4015     if test \"x\$destdir\" != \"x\$file\"; then
   4016       case \"\$destdir\" in
   4017       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
   4018       *) thisdir=\"\$thisdir/\$destdir\" ;;
   4019       esac
   4020     fi
   4021 
   4022     file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
   4023     file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
   4024   done
   4025 
   4026   # Usually 'no', except on cygwin/mingw when embedded into
   4027   # the cwrapper.
   4028   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
   4029   if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
   4030     # special case for '.'
   4031     if test \"\$thisdir\" = \".\"; then
   4032       thisdir=\`pwd\`
   4033     fi
   4034     # remove .libs from thisdir
   4035     case \"\$thisdir\" in
   4036     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
   4037     $objdir )   thisdir=. ;;
   4038     esac
   4039   fi
   4040 
   4041   # Try to get the absolute directory name.
   4042   absdir=\`cd \"\$thisdir\" && pwd\`
   4043   test -n \"\$absdir\" && thisdir=\"\$absdir\"
   4044 "
   4045 
   4046 	if test "$fast_install" = yes; then
   4047 	  $ECHO "\
   4048   program=lt-'$outputname'$exeext
   4049   progdir=\"\$thisdir/$objdir\"
   4050 
   4051   if test ! -f \"\$progdir/\$program\" ||
   4052      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
   4053        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
   4054 
   4055     file=\"\$\$-\$program\"
   4056 
   4057     if test ! -d \"\$progdir\"; then
   4058       $MKDIR \"\$progdir\"
   4059     else
   4060       $RM \"\$progdir/\$file\"
   4061     fi"
   4062 
   4063 	  $ECHO "\
   4064 
   4065     # relink executable if necessary
   4066     if test -n \"\$relink_command\"; then
   4067       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
   4068       else
   4069 	$ECHO \"\$relink_command_output\" >&2
   4070 	$RM \"\$progdir/\$file\"
   4071 	exit 1
   4072       fi
   4073     fi
   4074 
   4075     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
   4076     { $RM \"\$progdir/\$program\";
   4077       $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
   4078     $RM \"\$progdir/\$file\"
   4079   fi"
   4080 	else
   4081 	  $ECHO "\
   4082   program='$outputname'
   4083   progdir=\"\$thisdir/$objdir\"
   4084 "
   4085 	fi
   4086 
   4087 	$ECHO "\
   4088 
   4089   if test -f \"\$progdir/\$program\"; then"
   4090 
   4091 	# fixup the dll searchpath if we need to.
   4092 	#
   4093 	# Fix the DLL searchpath if we need to.  Do this before prepending
   4094 	# to shlibpath, because on Windows, both are PATH and uninstalled
   4095 	# libraries must come first.
   4096 	if test -n "$dllsearchpath"; then
   4097 	  $ECHO "\
   4098     # Add the dll search path components to the executable PATH
   4099     PATH=$dllsearchpath:\$PATH
   4100 "
   4101 	fi
   4102 
   4103 	# Export our shlibpath_var if we have one.
   4104 	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
   4105 	  $ECHO "\
   4106     # Add our own library path to $shlibpath_var
   4107     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
   4108 
   4109     # Some systems cannot cope with colon-terminated $shlibpath_var
   4110     # The second colon is a workaround for a bug in BeOS R4 sed
   4111     $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
   4112 
   4113     export $shlibpath_var
   4114 "
   4115 	fi
   4116 
   4117 	$ECHO "\
   4118     if test \"\$libtool_execute_magic\" != \"$magic\"; then
   4119       # Run the actual program with our arguments.
   4120       func_exec_program \${1+\"\$@\"}
   4121     fi
   4122   else
   4123     # The program doesn't exist.
   4124     \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
   4125     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
   4126     \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
   4127     exit 1
   4128   fi
   4129 fi\
   4130 "
   4131 }
   4132 
   4133 
   4134 # func_emit_cwrapperexe_src
   4135 # emit the source code for a wrapper executable on stdout
   4136 # Must ONLY be called from within func_mode_link because
   4137 # it depends on a number of variable set therein.
   4138 func_emit_cwrapperexe_src ()
   4139 {
   4140 	cat <<EOF
   4141 
   4142 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
   4143    Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
   4144 
   4145    The $output program cannot be directly executed until all the libtool
   4146    libraries that it depends on are installed.
   4147 
   4148    This wrapper executable should never be moved out of the build directory.
   4149    If it is, it will not operate correctly.
   4150 */
   4151 EOF
   4152 	    cat <<"EOF"
   4153 #ifdef _MSC_VER
   4154 # define _CRT_SECURE_NO_DEPRECATE 1
   4155 #endif
   4156 #include <stdio.h>
   4157 #include <stdlib.h>
   4158 #ifdef _MSC_VER
   4159 # include <direct.h>
   4160 # include <process.h>
   4161 # include <io.h>
   4162 #else
   4163 # include <unistd.h>
   4164 # include <stdint.h>
   4165 # ifdef __CYGWIN__
   4166 #  include <io.h>
   4167 # endif
   4168 #endif
   4169 #include <malloc.h>
   4170 #include <stdarg.h>
   4171 #include <assert.h>
   4172 #include <string.h>
   4173 #include <ctype.h>
   4174 #include <errno.h>
   4175 #include <fcntl.h>
   4176 #include <sys/stat.h>
   4177 
   4178 /* declarations of non-ANSI functions */
   4179 #if defined(__MINGW32__)
   4180 # ifdef __STRICT_ANSI__
   4181 int _putenv (const char *);
   4182 # endif
   4183 #elif defined(__CYGWIN__)
   4184 # ifdef __STRICT_ANSI__
   4185 char *realpath (const char *, char *);
   4186 int putenv (char *);
   4187 int setenv (const char *, const char *, int);
   4188 # endif
   4189 /* #elif defined (other platforms) ... */
   4190 #endif
   4191 
   4192 /* portability defines, excluding path handling macros */
   4193 #if defined(_MSC_VER)
   4194 # define setmode _setmode
   4195 # define stat    _stat
   4196 # define chmod   _chmod
   4197 # define getcwd  _getcwd
   4198 # define putenv  _putenv
   4199 # define S_IXUSR _S_IEXEC
   4200 # ifndef _INTPTR_T_DEFINED
   4201 #  define _INTPTR_T_DEFINED
   4202 #  define intptr_t int
   4203 # endif
   4204 #elif defined(__MINGW32__)
   4205 # define setmode _setmode
   4206 # define stat    _stat
   4207 # define chmod   _chmod
   4208 # define getcwd  _getcwd
   4209 # define putenv  _putenv
   4210 #elif defined(__CYGWIN__)
   4211 # define HAVE_SETENV
   4212 # define FOPEN_WB "wb"
   4213 /* #elif defined (other platforms) ... */
   4214 #endif
   4215 
   4216 #if defined(PATH_MAX)
   4217 # define LT_PATHMAX PATH_MAX
   4218 #elif defined(MAXPATHLEN)
   4219 # define LT_PATHMAX MAXPATHLEN
   4220 #else
   4221 # define LT_PATHMAX 1024
   4222 #endif
   4223 
   4224 #ifndef S_IXOTH
   4225 # define S_IXOTH 0
   4226 #endif
   4227 #ifndef S_IXGRP
   4228 # define S_IXGRP 0
   4229 #endif
   4230 
   4231 /* path handling portability macros */
   4232 #ifndef DIR_SEPARATOR
   4233 # define DIR_SEPARATOR '/'
   4234 # define PATH_SEPARATOR ':'
   4235 #endif
   4236 
   4237 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
   4238   defined (__OS2__)
   4239 # define HAVE_DOS_BASED_FILE_SYSTEM
   4240 # define FOPEN_WB "wb"
   4241 # ifndef DIR_SEPARATOR_2
   4242 #  define DIR_SEPARATOR_2 '\\'
   4243 # endif
   4244 # ifndef PATH_SEPARATOR_2
   4245 #  define PATH_SEPARATOR_2 ';'
   4246 # endif
   4247 #endif
   4248 
   4249 #ifndef DIR_SEPARATOR_2
   4250 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
   4251 #else /* DIR_SEPARATOR_2 */
   4252 # define IS_DIR_SEPARATOR(ch) \
   4253 	(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
   4254 #endif /* DIR_SEPARATOR_2 */
   4255 
   4256 #ifndef PATH_SEPARATOR_2
   4257 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
   4258 #else /* PATH_SEPARATOR_2 */
   4259 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
   4260 #endif /* PATH_SEPARATOR_2 */
   4261 
   4262 #ifndef FOPEN_WB
   4263 # define FOPEN_WB "w"
   4264 #endif
   4265 #ifndef _O_BINARY
   4266 # define _O_BINARY 0
   4267 #endif
   4268 
   4269 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
   4270 #define XFREE(stale) do { \
   4271   if (stale) { free ((void *) stale); stale = 0; } \
   4272 } while (0)
   4273 
   4274 #if defined(LT_DEBUGWRAPPER)
   4275 static int lt_debug = 1;
   4276 #else
   4277 static int lt_debug = 0;
   4278 #endif
   4279 
   4280 const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
   4281 
   4282 void *xmalloc (size_t num);
   4283 char *xstrdup (const char *string);
   4284 const char *base_name (const char *name);
   4285 char *find_executable (const char *wrapper);
   4286 char *chase_symlinks (const char *pathspec);
   4287 int make_executable (const char *path);
   4288 int check_executable (const char *path);
   4289 char *strendzap (char *str, const char *pat);
   4290 void lt_debugprintf (const char *file, int line, const char *fmt, ...);
   4291 void lt_fatal (const char *file, int line, const char *message, ...);
   4292 static const char *nonnull (const char *s);
   4293 static const char *nonempty (const char *s);
   4294 void lt_setenv (const char *name, const char *value);
   4295 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
   4296 void lt_update_exe_path (const char *name, const char *value);
   4297 void lt_update_lib_path (const char *name, const char *value);
   4298 char **prepare_spawn (char **argv);
   4299 void lt_dump_script (FILE *f);
   4300 EOF
   4301 
   4302 	    cat <<EOF
   4303 volatile const char * MAGIC_EXE = "$magic_exe";
   4304 const char * LIB_PATH_VARNAME = "$shlibpath_var";
   4305 EOF
   4306 
   4307 	    if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
   4308               func_to_host_path "$temp_rpath"
   4309 	      cat <<EOF
   4310 const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
   4311 EOF
   4312 	    else
   4313 	      cat <<"EOF"
   4314 const char * LIB_PATH_VALUE   = "";
   4315 EOF
   4316 	    fi
   4317 
   4318 	    if test -n "$dllsearchpath"; then
   4319               func_to_host_path "$dllsearchpath:"
   4320 	      cat <<EOF
   4321 const char * EXE_PATH_VARNAME = "PATH";
   4322 const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
   4323 EOF
   4324 	    else
   4325 	      cat <<"EOF"
   4326 const char * EXE_PATH_VARNAME = "";
   4327 const char * EXE_PATH_VALUE   = "";
   4328 EOF
   4329 	    fi
   4330 
   4331 	    if test "$fast_install" = yes; then
   4332 	      cat <<EOF
   4333 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
   4334 EOF
   4335 	    else
   4336 	      cat <<EOF
   4337 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
   4338 EOF
   4339 	    fi
   4340 
   4341 
   4342 	    cat <<"EOF"
   4343 
   4344 #define LTWRAPPER_OPTION_PREFIX         "--lt-"
   4345 
   4346 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
   4347 static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
   4348 static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
   4349 
   4350 int
   4351 main (int argc, char *argv[])
   4352 {
   4353   char **newargz;
   4354   int  newargc;
   4355   char *tmp_pathspec;
   4356   char *actual_cwrapper_path;
   4357   char *actual_cwrapper_name;
   4358   char *target_name;
   4359   char *lt_argv_zero;
   4360   intptr_t rval = 127;
   4361 
   4362   int i;
   4363 
   4364   program_name = (char *) xstrdup (base_name (argv[0]));
   4365   newargz = XMALLOC (char *, argc + 1);
   4366 
   4367   /* very simple arg parsing; don't want to rely on getopt
   4368    * also, copy all non cwrapper options to newargz, except
   4369    * argz[0], which is handled differently
   4370    */
   4371   newargc=0;
   4372   for (i = 1; i < argc; i++)
   4373     {
   4374       if (strcmp (argv[i], dumpscript_opt) == 0)
   4375 	{
   4376 EOF
   4377 	    case "$host" in
   4378 	      *mingw* | *cygwin* )
   4379 		# make stdout use "unix" line endings
   4380 		echo "          setmode(1,_O_BINARY);"
   4381 		;;
   4382 	      esac
   4383 
   4384 	    cat <<"EOF"
   4385 	  lt_dump_script (stdout);
   4386 	  return 0;
   4387 	}
   4388       if (strcmp (argv[i], debug_opt) == 0)
   4389 	{
   4390           lt_debug = 1;
   4391           continue;
   4392 	}
   4393       if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
   4394         {
   4395           /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
   4396              namespace, but it is not one of the ones we know about and
   4397              have already dealt with, above (inluding dump-script), then
   4398              report an error. Otherwise, targets might begin to believe
   4399              they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
   4400              namespace. The first time any user complains about this, we'll
   4401              need to make LTWRAPPER_OPTION_PREFIX a configure-time option
   4402              or a configure.ac-settable value.
   4403            */
   4404           lt_fatal (__FILE__, __LINE__,
   4405 		    "unrecognized %s option: '%s'",
   4406                     ltwrapper_option_prefix, argv[i]);
   4407         }
   4408       /* otherwise ... */
   4409       newargz[++newargc] = xstrdup (argv[i]);
   4410     }
   4411   newargz[++newargc] = NULL;
   4412 
   4413 EOF
   4414 	    cat <<EOF
   4415   /* The GNU banner must be the first non-error debug message */
   4416   lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
   4417 EOF
   4418 	    cat <<"EOF"
   4419   lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
   4420   lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
   4421 
   4422   tmp_pathspec = find_executable (argv[0]);
   4423   if (tmp_pathspec == NULL)
   4424     lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
   4425   lt_debugprintf (__FILE__, __LINE__,
   4426                   "(main) found exe (before symlink chase) at: %s\n",
   4427 		  tmp_pathspec);
   4428 
   4429   actual_cwrapper_path = chase_symlinks (tmp_pathspec);
   4430   lt_debugprintf (__FILE__, __LINE__,
   4431                   "(main) found exe (after symlink chase) at: %s\n",
   4432 		  actual_cwrapper_path);
   4433   XFREE (tmp_pathspec);
   4434 
   4435   actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
   4436   strendzap (actual_cwrapper_path, actual_cwrapper_name);
   4437 
   4438   /* wrapper name transforms */
   4439   strendzap (actual_cwrapper_name, ".exe");
   4440   tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
   4441   XFREE (actual_cwrapper_name);
   4442   actual_cwrapper_name = tmp_pathspec;
   4443   tmp_pathspec = 0;
   4444 
   4445   /* target_name transforms -- use actual target program name; might have lt- prefix */
   4446   target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
   4447   strendzap (target_name, ".exe");
   4448   tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
   4449   XFREE (target_name);
   4450   target_name = tmp_pathspec;
   4451   tmp_pathspec = 0;
   4452 
   4453   lt_debugprintf (__FILE__, __LINE__,
   4454 		  "(main) libtool target name: %s\n",
   4455 		  target_name);
   4456 EOF
   4457 
   4458 	    cat <<EOF
   4459   newargz[0] =
   4460     XMALLOC (char, (strlen (actual_cwrapper_path) +
   4461 		    strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
   4462   strcpy (newargz[0], actual_cwrapper_path);
   4463   strcat (newargz[0], "$objdir");
   4464   strcat (newargz[0], "/");
   4465 EOF
   4466 
   4467 	    cat <<"EOF"
   4468   /* stop here, and copy so we don't have to do this twice */
   4469   tmp_pathspec = xstrdup (newargz[0]);
   4470 
   4471   /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
   4472   strcat (newargz[0], actual_cwrapper_name);
   4473 
   4474   /* DO want the lt- prefix here if it exists, so use target_name */
   4475   lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
   4476   XFREE (tmp_pathspec);
   4477   tmp_pathspec = NULL;
   4478 EOF
   4479 
   4480 	    case $host_os in
   4481 	      mingw*)
   4482 	    cat <<"EOF"
   4483   {
   4484     char* p;
   4485     while ((p = strchr (newargz[0], '\\')) != NULL)
   4486       {
   4487 	*p = '/';
   4488       }
   4489     while ((p = strchr (lt_argv_zero, '\\')) != NULL)
   4490       {
   4491 	*p = '/';
   4492       }
   4493   }
   4494 EOF
   4495 	    ;;
   4496 	    esac
   4497 
   4498 	    cat <<"EOF"
   4499   XFREE (target_name);
   4500   XFREE (actual_cwrapper_path);
   4501   XFREE (actual_cwrapper_name);
   4502 
   4503   lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
   4504   lt_setenv ("DUALCASE", "1");  /* for MSK sh */
   4505   /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
   4506      be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
   4507      because on Windows, both *_VARNAMEs are PATH but uninstalled
   4508      libraries must come first. */
   4509   lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
   4510   lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
   4511 
   4512   lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
   4513 		  nonnull (lt_argv_zero));
   4514   for (i = 0; i < newargc; i++)
   4515     {
   4516       lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
   4517 		      i, nonnull (newargz[i]));
   4518     }
   4519 
   4520 EOF
   4521 
   4522 	    case $host_os in
   4523 	      mingw*)
   4524 		cat <<"EOF"
   4525   /* execv doesn't actually work on mingw as expected on unix */
   4526   newargz = prepare_spawn (newargz);
   4527   rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
   4528   if (rval == -1)
   4529     {
   4530       /* failed to start process */
   4531       lt_debugprintf (__FILE__, __LINE__,
   4532 		      "(main) failed to launch target \"%s\": %s\n",
   4533 		      lt_argv_zero, nonnull (strerror (errno)));
   4534       return 127;
   4535     }
   4536   return rval;
   4537 EOF
   4538 		;;
   4539 	      *)
   4540 		cat <<"EOF"
   4541   execv (lt_argv_zero, newargz);
   4542   return rval; /* =127, but avoids unused variable warning */
   4543 EOF
   4544 		;;
   4545 	    esac
   4546 
   4547 	    cat <<"EOF"
   4548 }
   4549 
   4550 void *
   4551 xmalloc (size_t num)
   4552 {
   4553   void *p = (void *) malloc (num);
   4554   if (!p)
   4555     lt_fatal (__FILE__, __LINE__, "memory exhausted");
   4556 
   4557   return p;
   4558 }
   4559 
   4560 char *
   4561 xstrdup (const char *string)
   4562 {
   4563   return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
   4564 			  string) : NULL;
   4565 }
   4566 
   4567 const char *
   4568 base_name (const char *name)
   4569 {
   4570   const char *base;
   4571 
   4572 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
   4573   /* Skip over the disk name in MSDOS pathnames. */
   4574   if (isalpha ((unsigned char) name[0]) && name[1] == ':')
   4575     name += 2;
   4576 #endif
   4577 
   4578   for (base = name; *name; name++)
   4579     if (IS_DIR_SEPARATOR (*name))
   4580       base = name + 1;
   4581   return base;
   4582 }
   4583 
   4584 int
   4585 check_executable (const char *path)
   4586 {
   4587   struct stat st;
   4588 
   4589   lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
   4590                   nonempty (path));
   4591   if ((!path) || (!*path))
   4592     return 0;
   4593 
   4594   if ((stat (path, &st) >= 0)
   4595       && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
   4596     return 1;
   4597   else
   4598     return 0;
   4599 }
   4600 
   4601 int
   4602 make_executable (const char *path)
   4603 {
   4604   int rval = 0;
   4605   struct stat st;
   4606 
   4607   lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
   4608                   nonempty (path));
   4609   if ((!path) || (!*path))
   4610     return 0;
   4611 
   4612   if (stat (path, &st) >= 0)
   4613     {
   4614       rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
   4615     }
   4616   return rval;
   4617 }
   4618 
   4619 /* Searches for the full path of the wrapper.  Returns
   4620    newly allocated full path name if found, NULL otherwise
   4621    Does not chase symlinks, even on platforms that support them.
   4622 */
   4623 char *
   4624 find_executable (const char *wrapper)
   4625 {
   4626   int has_slash = 0;
   4627   const char *p;
   4628   const char *p_next;
   4629   /* static buffer for getcwd */
   4630   char tmp[LT_PATHMAX + 1];
   4631   int tmp_len;
   4632   char *concat_name;
   4633 
   4634   lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
   4635                   nonempty (wrapper));
   4636 
   4637   if ((wrapper == NULL) || (*wrapper == '\0'))
   4638     return NULL;
   4639 
   4640   /* Absolute path? */
   4641 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
   4642   if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
   4643     {
   4644       concat_name = xstrdup (wrapper);
   4645       if (check_executable (concat_name))
   4646 	return concat_name;
   4647       XFREE (concat_name);
   4648     }
   4649   else
   4650     {
   4651 #endif
   4652       if (IS_DIR_SEPARATOR (wrapper[0]))
   4653 	{
   4654 	  concat_name = xstrdup (wrapper);
   4655 	  if (check_executable (concat_name))
   4656 	    return concat_name;
   4657 	  XFREE (concat_name);
   4658 	}
   4659 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
   4660     }
   4661 #endif
   4662 
   4663   for (p = wrapper; *p; p++)
   4664     if (*p == '/')
   4665       {
   4666 	has_slash = 1;
   4667 	break;
   4668       }
   4669   if (!has_slash)
   4670     {
   4671       /* no slashes; search PATH */
   4672       const char *path = getenv ("PATH");
   4673       if (path != NULL)
   4674 	{
   4675 	  for (p = path; *p; p = p_next)
   4676 	    {
   4677 	      const char *q;
   4678 	      size_t p_len;
   4679 	      for (q = p; *q; q++)
   4680 		if (IS_PATH_SEPARATOR (*q))
   4681 		  break;
   4682 	      p_len = q - p;
   4683 	      p_next = (*q == '\0' ? q : q + 1);
   4684 	      if (p_len == 0)
   4685 		{
   4686 		  /* empty path: current directory */
   4687 		  if (getcwd (tmp, LT_PATHMAX) == NULL)
   4688 		    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
   4689                               nonnull (strerror (errno)));
   4690 		  tmp_len = strlen (tmp);
   4691 		  concat_name =
   4692 		    XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
   4693 		  memcpy (concat_name, tmp, tmp_len);
   4694 		  concat_name[tmp_len] = '/';
   4695 		  strcpy (concat_name + tmp_len + 1, wrapper);
   4696 		}
   4697 	      else
   4698 		{
   4699 		  concat_name =
   4700 		    XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
   4701 		  memcpy (concat_name, p, p_len);
   4702 		  concat_name[p_len] = '/';
   4703 		  strcpy (concat_name + p_len + 1, wrapper);
   4704 		}
   4705 	      if (check_executable (concat_name))
   4706 		return concat_name;
   4707 	      XFREE (concat_name);
   4708 	    }
   4709 	}
   4710       /* not found in PATH; assume curdir */
   4711     }
   4712   /* Relative path | not found in path: prepend cwd */
   4713   if (getcwd (tmp, LT_PATHMAX) == NULL)
   4714     lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
   4715               nonnull (strerror (errno)));
   4716   tmp_len = strlen (tmp);
   4717   concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
   4718   memcpy (concat_name, tmp, tmp_len);
   4719   concat_name[tmp_len] = '/';
   4720   strcpy (concat_name + tmp_len + 1, wrapper);
   4721 
   4722   if (check_executable (concat_name))
   4723     return concat_name;
   4724   XFREE (concat_name);
   4725   return NULL;
   4726 }
   4727 
   4728 char *
   4729 chase_symlinks (const char *pathspec)
   4730 {
   4731 #ifndef S_ISLNK
   4732   return xstrdup (pathspec);
   4733 #else
   4734   char buf[LT_PATHMAX];
   4735   struct stat s;
   4736   char *tmp_pathspec = xstrdup (pathspec);
   4737   char *p;
   4738   int has_symlinks = 0;
   4739   while (strlen (tmp_pathspec) && !has_symlinks)
   4740     {
   4741       lt_debugprintf (__FILE__, __LINE__,
   4742 		      "checking path component for symlinks: %s\n",
   4743 		      tmp_pathspec);
   4744       if (lstat (tmp_pathspec, &s) == 0)
   4745 	{
   4746 	  if (S_ISLNK (s.st_mode) != 0)
   4747 	    {
   4748 	      has_symlinks = 1;
   4749 	      break;
   4750 	    }
   4751 
   4752 	  /* search backwards for last DIR_SEPARATOR */
   4753 	  p = tmp_pathspec + strlen (tmp_pathspec) - 1;
   4754 	  while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
   4755 	    p--;
   4756 	  if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
   4757 	    {
   4758 	      /* no more DIR_SEPARATORS left */
   4759 	      break;
   4760 	    }
   4761 	  *p = '\0';
   4762 	}
   4763       else
   4764 	{
   4765 	  lt_fatal (__FILE__, __LINE__,
   4766 		    "error accessing file \"%s\": %s",
   4767 		    tmp_pathspec, nonnull (strerror (errno)));
   4768 	}
   4769     }
   4770   XFREE (tmp_pathspec);
   4771 
   4772   if (!has_symlinks)
   4773     {
   4774       return xstrdup (pathspec);
   4775     }
   4776 
   4777   tmp_pathspec = realpath (pathspec, buf);
   4778   if (tmp_pathspec == 0)
   4779     {
   4780       lt_fatal (__FILE__, __LINE__,
   4781 		"could not follow symlinks for %s", pathspec);
   4782     }
   4783   return xstrdup (tmp_pathspec);
   4784 #endif
   4785 }
   4786 
   4787 char *
   4788 strendzap (char *str, const char *pat)
   4789 {
   4790   size_t len, patlen;
   4791 
   4792   assert (str != NULL);
   4793   assert (pat != NULL);
   4794 
   4795   len = strlen (str);
   4796   patlen = strlen (pat);
   4797 
   4798   if (patlen <= len)
   4799     {
   4800       str += len - patlen;
   4801       if (strcmp (str, pat) == 0)
   4802 	*str = '\0';
   4803     }
   4804   return str;
   4805 }
   4806 
   4807 void
   4808 lt_debugprintf (const char *file, int line, const char *fmt, ...)
   4809 {
   4810   va_list args;
   4811   if (lt_debug)
   4812     {
   4813       (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
   4814       va_start (args, fmt);
   4815       (void) vfprintf (stderr, fmt, args);
   4816       va_end (args);
   4817     }
   4818 }
   4819 
   4820 static void
   4821 lt_error_core (int exit_status, const char *file,
   4822 	       int line, const char *mode,
   4823 	       const char *message, va_list ap)
   4824 {
   4825   fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
   4826   vfprintf (stderr, message, ap);
   4827   fprintf (stderr, ".\n");
   4828 
   4829   if (exit_status >= 0)
   4830     exit (exit_status);
   4831 }
   4832 
   4833 void
   4834 lt_fatal (const char *file, int line, const char *message, ...)
   4835 {
   4836   va_list ap;
   4837   va_start (ap, message);
   4838   lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
   4839   va_end (ap);
   4840 }
   4841 
   4842 static const char *
   4843 nonnull (const char *s)
   4844 {
   4845   return s ? s : "(null)";
   4846 }
   4847 
   4848 static const char *
   4849 nonempty (const char *s)
   4850 {
   4851   return (s && !*s) ? "(empty)" : nonnull (s);
   4852 }
   4853 
   4854 void
   4855 lt_setenv (const char *name, const char *value)
   4856 {
   4857   lt_debugprintf (__FILE__, __LINE__,
   4858 		  "(lt_setenv) setting '%s' to '%s'\n",
   4859                   nonnull (name), nonnull (value));
   4860   {
   4861 #ifdef HAVE_SETENV
   4862     /* always make a copy, for consistency with !HAVE_SETENV */
   4863     char *str = xstrdup (value);
   4864     setenv (name, str, 1);
   4865 #else
   4866     int len = strlen (name) + 1 + strlen (value) + 1;
   4867     char *str = XMALLOC (char, len);
   4868     sprintf (str, "%s=%s", name, value);
   4869     if (putenv (str) != EXIT_SUCCESS)
   4870       {
   4871         XFREE (str);
   4872       }
   4873 #endif
   4874   }
   4875 }
   4876 
   4877 char *
   4878 lt_extend_str (const char *orig_value, const char *add, int to_end)
   4879 {
   4880   char *new_value;
   4881   if (orig_value && *orig_value)
   4882     {
   4883       int orig_value_len = strlen (orig_value);
   4884       int add_len = strlen (add);
   4885       new_value = XMALLOC (char, add_len + orig_value_len + 1);
   4886       if (to_end)
   4887         {
   4888           strcpy (new_value, orig_value);
   4889           strcpy (new_value + orig_value_len, add);
   4890         }
   4891       else
   4892         {
   4893           strcpy (new_value, add);
   4894           strcpy (new_value + add_len, orig_value);
   4895         }
   4896     }
   4897   else
   4898     {
   4899       new_value = xstrdup (add);
   4900     }
   4901   return new_value;
   4902 }
   4903 
   4904 void
   4905 lt_update_exe_path (const char *name, const char *value)
   4906 {
   4907   lt_debugprintf (__FILE__, __LINE__,
   4908 		  "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
   4909                   nonnull (name), nonnull (value));
   4910 
   4911   if (name && *name && value && *value)
   4912     {
   4913       char *new_value = lt_extend_str (getenv (name), value, 0);
   4914       /* some systems can't cope with a ':'-terminated path #' */
   4915       int len = strlen (new_value);
   4916       while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
   4917         {
   4918           new_value[len-1] = '\0';
   4919         }
   4920       lt_setenv (name, new_value);
   4921       XFREE (new_value);
   4922     }
   4923 }
   4924 
   4925 void
   4926 lt_update_lib_path (const char *name, const char *value)
   4927 {
   4928   lt_debugprintf (__FILE__, __LINE__,
   4929 		  "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
   4930                   nonnull (name), nonnull (value));
   4931 
   4932   if (name && *name && value && *value)
   4933     {
   4934       char *new_value = lt_extend_str (getenv (name), value, 0);
   4935       lt_setenv (name, new_value);
   4936       XFREE (new_value);
   4937     }
   4938 }
   4939 
   4940 EOF
   4941 	    case $host_os in
   4942 	      mingw*)
   4943 		cat <<"EOF"
   4944 
   4945 /* Prepares an argument vector before calling spawn().
   4946    Note that spawn() does not by itself call the command interpreter
   4947      (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
   4948       ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
   4949          GetVersionEx(&v);
   4950          v.dwPlatformId == VER_PLATFORM_WIN32_NT;
   4951       }) ? "cmd.exe" : "command.com").
   4952    Instead it simply concatenates the arguments, separated by ' ', and calls
   4953    CreateProcess().  We must quote the arguments since Win32 CreateProcess()
   4954    interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
   4955    special way:
   4956    - Space and tab are interpreted as delimiters. They are not treated as
   4957      delimiters if they are surrounded by double quotes: "...".
   4958    - Unescaped double quotes are removed from the input. Their only effect is
   4959      that within double quotes, space and tab are treated like normal
   4960      characters.
   4961    - Backslashes not followed by double quotes are not special.
   4962    - But 2*n+1 backslashes followed by a double quote become
   4963      n backslashes followed by a double quote (n >= 0):
   4964        \" -> "
   4965        \\\" -> \"
   4966        \\\\\" -> \\"
   4967  */
   4968 #define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
   4969 #define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
   4970 char **
   4971 prepare_spawn (char **argv)
   4972 {
   4973   size_t argc;
   4974   char **new_argv;
   4975   size_t i;
   4976 
   4977   /* Count number of arguments.  */
   4978   for (argc = 0; argv[argc] != NULL; argc++)
   4979     ;
   4980 
   4981   /* Allocate new argument vector.  */
   4982   new_argv = XMALLOC (char *, argc + 1);
   4983 
   4984   /* Put quoted arguments into the new argument vector.  */
   4985   for (i = 0; i < argc; i++)
   4986     {
   4987       const char *string = argv[i];
   4988 
   4989       if (string[0] == '\0')
   4990 	new_argv[i] = xstrdup ("\"\"");
   4991       else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
   4992 	{
   4993 	  int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
   4994 	  size_t length;
   4995 	  unsigned int backslashes;
   4996 	  const char *s;
   4997 	  char *quoted_string;
   4998 	  char *p;
   4999 
   5000 	  length = 0;
   5001 	  backslashes = 0;
   5002 	  if (quote_around)
   5003 	    length++;
   5004 	  for (s = string; *s != '\0'; s++)
   5005 	    {
   5006 	      char c = *s;
   5007 	      if (c == '"')
   5008 		length += backslashes + 1;
   5009 	      length++;
   5010 	      if (c == '\\')
   5011 		backslashes++;
   5012 	      else
   5013 		backslashes = 0;
   5014 	    }
   5015 	  if (quote_around)
   5016 	    length += backslashes + 1;
   5017 
   5018 	  quoted_string = XMALLOC (char, length + 1);
   5019 
   5020 	  p = quoted_string;
   5021 	  backslashes = 0;
   5022 	  if (quote_around)
   5023 	    *p++ = '"';
   5024 	  for (s = string; *s != '\0'; s++)
   5025 	    {
   5026 	      char c = *s;
   5027 	      if (c == '"')
   5028 		{
   5029 		  unsigned int j;
   5030 		  for (j = backslashes + 1; j > 0; j--)
   5031 		    *p++ = '\\';
   5032 		}
   5033 	      *p++ = c;
   5034 	      if (c == '\\')
   5035 		backslashes++;
   5036 	      else
   5037 		backslashes = 0;
   5038 	    }
   5039 	  if (quote_around)
   5040 	    {
   5041 	      unsigned int j;
   5042 	      for (j = backslashes; j > 0; j--)
   5043 		*p++ = '\\';
   5044 	      *p++ = '"';
   5045 	    }
   5046 	  *p = '\0';
   5047 
   5048 	  new_argv[i] = quoted_string;
   5049 	}
   5050       else
   5051 	new_argv[i] = (char *) string;
   5052     }
   5053   new_argv[argc] = NULL;
   5054 
   5055   return new_argv;
   5056 }
   5057 EOF
   5058 		;;
   5059 	    esac
   5060 
   5061             cat <<"EOF"
   5062 void lt_dump_script (FILE* f)
   5063 {
   5064 EOF
   5065 	    func_emit_wrapper yes |
   5066 	      $SED -n -e '
   5067 s/^\(.\{79\}\)\(..*\)/\1\
   5068 \2/
   5069 h
   5070 s/\([\\"]\)/\\\1/g
   5071 s/$/\\n/
   5072 s/\([^\n]*\).*/  fputs ("\1", f);/p
   5073 g
   5074 D'
   5075             cat <<"EOF"
   5076 }
   5077 EOF
   5078 }
   5079 # end: func_emit_cwrapperexe_src
   5080 
   5081 # func_win32_import_lib_p ARG
   5082 # True if ARG is an import lib, as indicated by $file_magic_cmd
   5083 func_win32_import_lib_p ()
   5084 {
   5085     $opt_debug
   5086     case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
   5087     *import*) : ;;
   5088     *) false ;;
   5089     esac
   5090 }
   5091 
   5092 # func_mode_link arg...
   5093 func_mode_link ()
   5094 {
   5095     $opt_debug
   5096     case $host in
   5097     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
   5098       # It is impossible to link a dll without this setting, and
   5099       # we shouldn't force the makefile maintainer to figure out
   5100       # which system we are compiling for in order to pass an extra
   5101       # flag for every libtool invocation.
   5102       # allow_undefined=no
   5103 
   5104       # FIXME: Unfortunately, there are problems with the above when trying
   5105       # to make a dll which has undefined symbols, in which case not
   5106       # even a static library is built.  For now, we need to specify
   5107       # -no-undefined on the libtool link line when we can be certain
   5108       # that all symbols are satisfied, otherwise we get a static library.
   5109       allow_undefined=yes
   5110       ;;
   5111     *)
   5112       allow_undefined=yes
   5113       ;;
   5114     esac
   5115     libtool_args=$nonopt
   5116     base_compile="$nonopt $@"
   5117     compile_command=$nonopt
   5118     finalize_command=$nonopt
   5119 
   5120     compile_rpath=
   5121     finalize_rpath=
   5122     compile_shlibpath=
   5123     finalize_shlibpath=
   5124     convenience=
   5125     old_convenience=
   5126     deplibs=
   5127     old_deplibs=
   5128     compiler_flags=
   5129     linker_flags=
   5130     dllsearchpath=
   5131     lib_search_path=`pwd`
   5132     inst_prefix_dir=
   5133     new_inherited_linker_flags=
   5134 
   5135     avoid_version=no
   5136     bindir=
   5137     dlfiles=
   5138     dlprefiles=
   5139     dlself=no
   5140     export_dynamic=no
   5141     export_symbols=
   5142     export_symbols_regex=
   5143     generated=
   5144     libobjs=
   5145     ltlibs=
   5146     module=no
   5147     no_install=no
   5148     objs=
   5149     non_pic_objects=
   5150     precious_files_regex=
   5151     prefer_static_libs=no
   5152     preload=no
   5153     prev=
   5154     prevarg=
   5155     release=
   5156     rpath=
   5157     xrpath=
   5158     perm_rpath=
   5159     temp_rpath=
   5160     thread_safe=no
   5161     vinfo=
   5162     vinfo_number=no
   5163     weak_libs=
   5164     single_module="${wl}-single_module"
   5165     func_infer_tag $base_compile
   5166 
   5167     # We need to know -static, to get the right output filenames.
   5168     for arg
   5169     do
   5170       case $arg in
   5171       -shared)
   5172 	test "$build_libtool_libs" != yes && \
   5173 	  func_fatal_configuration "can not build a shared library"
   5174 	build_old_libs=no
   5175 	break
   5176 	;;
   5177       -all-static | -static | -static-libtool-libs)
   5178 	case $arg in
   5179 	-all-static)
   5180 	  if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
   5181 	    func_warning "complete static linking is impossible in this configuration"
   5182 	  fi
   5183 	  if test -n "$link_static_flag"; then
   5184 	    dlopen_self=$dlopen_self_static
   5185 	  fi
   5186 	  prefer_static_libs=yes
   5187 	  ;;
   5188 	-static)
   5189 	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
   5190 	    dlopen_self=$dlopen_self_static
   5191 	  fi
   5192 	  prefer_static_libs=built
   5193 	  ;;
   5194 	-static-libtool-libs)
   5195 	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
   5196 	    dlopen_self=$dlopen_self_static
   5197 	  fi
   5198 	  prefer_static_libs=yes
   5199 	  ;;
   5200 	esac
   5201 	build_libtool_libs=no
   5202 	build_old_libs=yes
   5203 	break
   5204 	;;
   5205       esac
   5206     done
   5207 
   5208     # See if our shared archives depend on static archives.
   5209     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
   5210 
   5211     # Go through the arguments, transforming them on the way.
   5212     while test "$#" -gt 0; do
   5213       arg="$1"
   5214       shift
   5215       func_quote_for_eval "$arg"
   5216       qarg=$func_quote_for_eval_unquoted_result
   5217       func_append libtool_args " $func_quote_for_eval_result"
   5218 
   5219       # If the previous option needs an argument, assign it.
   5220       if test -n "$prev"; then
   5221 	case $prev in
   5222 	output)
   5223 	  func_append compile_command " @OUTPUT@"
   5224 	  func_append finalize_command " @OUTPUT@"
   5225 	  ;;
   5226 	esac
   5227 
   5228 	case $prev in
   5229 	bindir)
   5230 	  bindir="$arg"
   5231 	  prev=
   5232 	  continue
   5233 	  ;;
   5234 	dlfiles|dlprefiles)
   5235 	  if test "$preload" = no; then
   5236 	    # Add the symbol object into the linking commands.
   5237 	    func_append compile_command " @SYMFILE@"
   5238 	    func_append finalize_command " @SYMFILE@"
   5239 	    preload=yes
   5240 	  fi
   5241 	  case $arg in
   5242 	  *.la | *.lo) ;;  # We handle these cases below.
   5243 	  force)
   5244 	    if test "$dlself" = no; then
   5245 	      dlself=needless
   5246 	      export_dynamic=yes
   5247 	    fi
   5248 	    prev=
   5249 	    continue
   5250 	    ;;
   5251 	  self)
   5252 	    if test "$prev" = dlprefiles; then
   5253 	      dlself=yes
   5254 	    elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
   5255 	      dlself=yes
   5256 	    else
   5257 	      dlself=needless
   5258 	      export_dynamic=yes
   5259 	    fi
   5260 	    prev=
   5261 	    continue
   5262 	    ;;
   5263 	  *)
   5264 	    if test "$prev" = dlfiles; then
   5265 	      func_append dlfiles " $arg"
   5266 	    else
   5267 	      func_append dlprefiles " $arg"
   5268 	    fi
   5269 	    prev=
   5270 	    continue
   5271 	    ;;
   5272 	  esac
   5273 	  ;;
   5274 	expsyms)
   5275 	  export_symbols="$arg"
   5276 	  test -f "$arg" \
   5277 	    || func_fatal_error "symbol file \`$arg' does not exist"
   5278 	  prev=
   5279 	  continue
   5280 	  ;;
   5281 	expsyms_regex)
   5282 	  export_symbols_regex="$arg"
   5283 	  prev=
   5284 	  continue
   5285 	  ;;
   5286 	framework)
   5287 	  case $host in
   5288 	    *-*-darwin*)
   5289 	      case "$deplibs " in
   5290 		*" $qarg.ltframework "*) ;;
   5291 		*) func_append deplibs " $qarg.ltframework" # this is fixed later
   5292 		   ;;
   5293 	      esac
   5294 	      ;;
   5295 	  esac
   5296 	  prev=
   5297 	  continue
   5298 	  ;;
   5299 	inst_prefix)
   5300 	  inst_prefix_dir="$arg"
   5301 	  prev=
   5302 	  continue
   5303 	  ;;
   5304 	objectlist)
   5305 	  if test -f "$arg"; then
   5306 	    save_arg=$arg
   5307 	    moreargs=
   5308 	    for fil in `cat "$save_arg"`
   5309 	    do
   5310 #	      func_append moreargs " $fil"
   5311 	      arg=$fil
   5312 	      # A libtool-controlled object.
   5313 
   5314 	      # Check to see that this really is a libtool object.
   5315 	      if func_lalib_unsafe_p "$arg"; then
   5316 		pic_object=
   5317 		non_pic_object=
   5318 
   5319 		# Read the .lo file
   5320 		func_source "$arg"
   5321 
   5322 		if test -z "$pic_object" ||
   5323 		   test -z "$non_pic_object" ||
   5324 		   test "$pic_object" = none &&
   5325 		   test "$non_pic_object" = none; then
   5326 		  func_fatal_error "cannot find name of object for \`$arg'"
   5327 		fi
   5328 
   5329 		# Extract subdirectory from the argument.
   5330 		func_dirname "$arg" "/" ""
   5331 		xdir="$func_dirname_result"
   5332 
   5333 		if test "$pic_object" != none; then
   5334 		  # Prepend the subdirectory the object is found in.
   5335 		  pic_object="$xdir$pic_object"
   5336 
   5337 		  if test "$prev" = dlfiles; then
   5338 		    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
   5339 		      func_append dlfiles " $pic_object"
   5340 		      prev=
   5341 		      continue
   5342 		    else
   5343 		      # If libtool objects are unsupported, then we need to preload.
   5344 		      prev=dlprefiles
   5345 		    fi
   5346 		  fi
   5347 
   5348 		  # CHECK ME:  I think I busted this.  -Ossama
   5349 		  if test "$prev" = dlprefiles; then
   5350 		    # Preload the old-style object.
   5351 		    func_append dlprefiles " $pic_object"
   5352 		    prev=
   5353 		  fi
   5354 
   5355 		  # A PIC object.
   5356 		  func_append libobjs " $pic_object"
   5357 		  arg="$pic_object"
   5358 		fi
   5359 
   5360 		# Non-PIC object.
   5361 		if test "$non_pic_object" != none; then
   5362 		  # Prepend the subdirectory the object is found in.
   5363 		  non_pic_object="$xdir$non_pic_object"
   5364 
   5365 		  # A standard non-PIC object
   5366 		  func_append non_pic_objects " $non_pic_object"
   5367 		  if test -z "$pic_object" || test "$pic_object" = none ; then
   5368 		    arg="$non_pic_object"
   5369 		  fi
   5370 		else
   5371 		  # If the PIC object exists, use it instead.
   5372 		  # $xdir was prepended to $pic_object above.
   5373 		  non_pic_object="$pic_object"
   5374 		  func_append non_pic_objects " $non_pic_object"
   5375 		fi
   5376 	      else
   5377 		# Only an error if not doing a dry-run.
   5378 		if $opt_dry_run; then
   5379 		  # Extract subdirectory from the argument.
   5380 		  func_dirname "$arg" "/" ""
   5381 		  xdir="$func_dirname_result"
   5382 
   5383 		  func_lo2o "$arg"
   5384 		  pic_object=$xdir$objdir/$func_lo2o_result
   5385 		  non_pic_object=$xdir$func_lo2o_result
   5386 		  func_append libobjs " $pic_object"
   5387 		  func_append non_pic_objects " $non_pic_object"
   5388 	        else
   5389 		  func_fatal_error "\`$arg' is not a valid libtool object"
   5390 		fi
   5391 	      fi
   5392 	    done
   5393 	  else
   5394 	    func_fatal_error "link input file \`$arg' does not exist"
   5395 	  fi
   5396 	  arg=$save_arg
   5397 	  prev=
   5398 	  continue
   5399 	  ;;
   5400 	precious_regex)
   5401 	  precious_files_regex="$arg"
   5402 	  prev=
   5403 	  continue
   5404 	  ;;
   5405 	release)
   5406 	  release="-$arg"
   5407 	  prev=
   5408 	  continue
   5409 	  ;;
   5410 	rpath | xrpath)
   5411 	  # We need an absolute path.
   5412 	  case $arg in
   5413 	  [\\/]* | [A-Za-z]:[\\/]*) ;;
   5414 	  *)
   5415 	    func_fatal_error "only absolute run-paths are allowed"
   5416 	    ;;
   5417 	  esac
   5418 	  if test "$prev" = rpath; then
   5419 	    case "$rpath " in
   5420 	    *" $arg "*) ;;
   5421 	    *) func_append rpath " $arg" ;;
   5422 	    esac
   5423 	  else
   5424 	    case "$xrpath " in
   5425 	    *" $arg "*) ;;
   5426 	    *) func_append xrpath " $arg" ;;
   5427 	    esac
   5428 	  fi
   5429 	  prev=
   5430 	  continue
   5431 	  ;;
   5432 	shrext)
   5433 	  shrext_cmds="$arg"
   5434 	  prev=
   5435 	  continue
   5436 	  ;;
   5437 	weak)
   5438 	  func_append weak_libs " $arg"
   5439 	  prev=
   5440 	  continue
   5441 	  ;;
   5442 	xcclinker)
   5443 	  func_append linker_flags " $qarg"
   5444 	  func_append compiler_flags " $qarg"
   5445 	  prev=
   5446 	  func_append compile_command " $qarg"
   5447 	  func_append finalize_command " $qarg"
   5448 	  continue
   5449 	  ;;
   5450 	xcompiler)
   5451 	  func_append compiler_flags " $qarg"
   5452 	  prev=
   5453 	  func_append compile_command " $qarg"
   5454 	  func_append finalize_command " $qarg"
   5455 	  continue
   5456 	  ;;
   5457 	xlinker)
   5458 	  func_append linker_flags " $qarg"
   5459 	  func_append compiler_flags " $wl$qarg"
   5460 	  prev=
   5461 	  func_append compile_command " $wl$qarg"
   5462 	  func_append finalize_command " $wl$qarg"
   5463 	  continue
   5464 	  ;;
   5465 	*)
   5466 	  eval "$prev=\"\$arg\""
   5467 	  prev=
   5468 	  continue
   5469 	  ;;
   5470 	esac
   5471       fi # test -n "$prev"
   5472 
   5473       prevarg="$arg"
   5474 
   5475       case $arg in
   5476       -all-static)
   5477 	if test -n "$link_static_flag"; then
   5478 	  # See comment for -static flag below, for more details.
   5479 	  func_append compile_command " $link_static_flag"
   5480 	  func_append finalize_command " $link_static_flag"
   5481 	fi
   5482 	continue
   5483 	;;
   5484 
   5485       -allow-undefined)
   5486 	# FIXME: remove this flag sometime in the future.
   5487 	func_fatal_error "\`-allow-undefined' must not be used because it is the default"
   5488 	;;
   5489 
   5490       -avoid-version)
   5491 	avoid_version=yes
   5492 	continue
   5493 	;;
   5494 
   5495       -bindir)
   5496 	prev=bindir
   5497 	continue
   5498 	;;
   5499 
   5500       -dlopen)
   5501 	prev=dlfiles
   5502 	continue
   5503 	;;
   5504 
   5505       -dlpreopen)
   5506 	prev=dlprefiles
   5507 	continue
   5508 	;;
   5509 
   5510       -export-dynamic)
   5511 	export_dynamic=yes
   5512 	continue
   5513 	;;
   5514 
   5515       -export-symbols | -export-symbols-regex)
   5516 	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
   5517 	  func_fatal_error "more than one -exported-symbols argument is not allowed"
   5518 	fi
   5519 	if test "X$arg" = "X-export-symbols"; then
   5520 	  prev=expsyms
   5521 	else
   5522 	  prev=expsyms_regex
   5523 	fi
   5524 	continue
   5525 	;;
   5526 
   5527       -framework)
   5528 	prev=framework
   5529 	continue
   5530 	;;
   5531 
   5532       -inst-prefix-dir)
   5533 	prev=inst_prefix
   5534 	continue
   5535 	;;
   5536 
   5537       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
   5538       # so, if we see these flags be careful not to treat them like -L
   5539       -L[A-Z][A-Z]*:*)
   5540 	case $with_gcc/$host in
   5541 	no/*-*-irix* | /*-*-irix*)
   5542 	  func_append compile_command " $arg"
   5543 	  func_append finalize_command " $arg"
   5544 	  ;;
   5545 	esac
   5546 	continue
   5547 	;;
   5548 
   5549       -L*)
   5550 	func_stripname "-L" '' "$arg"
   5551 	if test -z "$func_stripname_result"; then
   5552 	  if test "$#" -gt 0; then
   5553 	    func_fatal_error "require no space between \`-L' and \`$1'"
   5554 	  else
   5555 	    func_fatal_error "need path for \`-L' option"
   5556 	  fi
   5557 	fi
   5558 	func_resolve_sysroot "$func_stripname_result"
   5559 	dir=$func_resolve_sysroot_result
   5560 	# We need an absolute path.
   5561 	case $dir in
   5562 	[\\/]* | [A-Za-z]:[\\/]*) ;;
   5563 	*)
   5564 	  absdir=`cd "$dir" && pwd`
   5565 	  test -z "$absdir" && \
   5566 	    func_fatal_error "cannot determine absolute directory name of \`$dir'"
   5567 	  dir="$absdir"
   5568 	  ;;
   5569 	esac
   5570 	case "$deplibs " in
   5571 	*" -L$dir "* | *" $arg "*)
   5572 	  # Will only happen for absolute or sysroot arguments
   5573 	  ;;
   5574 	*)
   5575 	  # Preserve sysroot, but never include relative directories
   5576 	  case $dir in
   5577 	    [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
   5578 	    *) func_append deplibs " -L$dir" ;;
   5579 	  esac
   5580 	  func_append lib_search_path " $dir"
   5581 	  ;;
   5582 	esac
   5583 	case $host in
   5584 	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
   5585 	  testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
   5586 	  case :$dllsearchpath: in
   5587 	  *":$dir:"*) ;;
   5588 	  ::) dllsearchpath=$dir;;
   5589 	  *) func_append dllsearchpath ":$dir";;
   5590 	  esac
   5591 	  case :$dllsearchpath: in
   5592 	  *":$testbindir:"*) ;;
   5593 	  ::) dllsearchpath=$testbindir;;
   5594 	  *) func_append dllsearchpath ":$testbindir";;
   5595 	  esac
   5596 	  ;;
   5597 	esac
   5598 	continue
   5599 	;;
   5600 
   5601       -l*)
   5602 	if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
   5603 	  case $host in
   5604 	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
   5605 	    # These systems don't actually have a C or math library (as such)
   5606 	    continue
   5607 	    ;;
   5608 	  *-*-os2*)
   5609 	    # These systems don't actually have a C library (as such)
   5610 	    test "X$arg" = "X-lc" && continue
   5611 	    ;;
   5612 	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
   5613 	    # Do not include libc due to us having libc/libc_r.
   5614 	    test "X$arg" = "X-lc" && continue
   5615 	    ;;
   5616 	  *-*-rhapsody* | *-*-darwin1.[012])
   5617 	    # Rhapsody C and math libraries are in the System framework
   5618 	    func_append deplibs " System.ltframework"
   5619 	    continue
   5620 	    ;;
   5621 	  *-*-sco3.2v5* | *-*-sco5v6*)
   5622 	    # Causes problems with __ctype
   5623 	    test "X$arg" = "X-lc" && continue
   5624 	    ;;
   5625 	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
   5626 	    # Compiler inserts libc in the correct place for threads to work
   5627 	    test "X$arg" = "X-lc" && continue
   5628 	    ;;
   5629 	  esac
   5630 	elif test "X$arg" = "X-lc_r"; then
   5631 	 case $host in
   5632 	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
   5633 	   # Do not include libc_r directly, use -pthread flag.
   5634 	   continue
   5635 	   ;;
   5636 	 esac
   5637 	fi
   5638 	func_append deplibs " $arg"
   5639 	continue
   5640 	;;
   5641 
   5642       -module)
   5643 	module=yes
   5644 	continue
   5645 	;;
   5646 
   5647       # Tru64 UNIX uses -model [arg] to determine the layout of C++
   5648       # classes, name mangling, and exception handling.
   5649       # Darwin uses the -arch flag to determine output architecture.
   5650       -model|-arch|-isysroot|--sysroot)
   5651 	func_append compiler_flags " $arg"
   5652 	func_append compile_command " $arg"
   5653 	func_append finalize_command " $arg"
   5654 	prev=xcompiler
   5655 	continue
   5656 	;;
   5657 
   5658       -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
   5659       |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
   5660 	func_append compiler_flags " $arg"
   5661 	func_append compile_command " $arg"
   5662 	func_append finalize_command " $arg"
   5663 	case "$new_inherited_linker_flags " in
   5664 	    *" $arg "*) ;;
   5665 	    * ) func_append new_inherited_linker_flags " $arg" ;;
   5666 	esac
   5667 	continue
   5668 	;;
   5669 
   5670       -multi_module)
   5671 	single_module="${wl}-multi_module"
   5672 	continue
   5673 	;;
   5674 
   5675       -no-fast-install)
   5676 	fast_install=no
   5677 	continue
   5678 	;;
   5679 
   5680       -no-install)
   5681 	case $host in
   5682 	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
   5683 	  # The PATH hackery in wrapper scripts is required on Windows
   5684 	  # and Darwin in order for the loader to find any dlls it needs.
   5685 	  func_warning "\`-no-install' is ignored for $host"
   5686 	  func_warning "assuming \`-no-fast-install' instead"
   5687 	  fast_install=no
   5688 	  ;;
   5689 	*) no_install=yes ;;
   5690 	esac
   5691 	continue
   5692 	;;
   5693 
   5694       -no-undefined)
   5695 	allow_undefined=no
   5696 	continue
   5697 	;;
   5698 
   5699       -objectlist)
   5700 	prev=objectlist
   5701 	continue
   5702 	;;
   5703 
   5704       -o) prev=output ;;
   5705 
   5706       -precious-files-regex)
   5707 	prev=precious_regex
   5708 	continue
   5709 	;;
   5710 
   5711       -release)
   5712 	prev=release
   5713 	continue
   5714 	;;
   5715 
   5716       -rpath)
   5717 	prev=rpath
   5718 	continue
   5719 	;;
   5720 
   5721       -R)
   5722 	prev=xrpath
   5723 	continue
   5724 	;;
   5725 
   5726       -R*)
   5727 	func_stripname '-R' '' "$arg"
   5728 	dir=$func_stripname_result
   5729 	# We need an absolute path.
   5730 	case $dir in
   5731 	[\\/]* | [A-Za-z]:[\\/]*) ;;
   5732 	=*)
   5733 	  func_stripname '=' '' "$dir"
   5734 	  dir=$lt_sysroot$func_stripname_result
   5735 	  ;;
   5736 	*)
   5737 	  func_fatal_error "only absolute run-paths are allowed"
   5738 	  ;;
   5739 	esac
   5740 	case "$xrpath " in
   5741 	*" $dir "*) ;;
   5742 	*) func_append xrpath " $dir" ;;
   5743 	esac
   5744 	continue
   5745 	;;
   5746 
   5747       -shared)
   5748 	# The effects of -shared are defined in a previous loop.
   5749 	continue
   5750 	;;
   5751 
   5752       -shrext)
   5753 	prev=shrext
   5754 	continue
   5755 	;;
   5756 
   5757       -static | -static-libtool-libs)
   5758 	# The effects of -static are defined in a previous loop.
   5759 	# We used to do the same as -all-static on platforms that
   5760 	# didn't have a PIC flag, but the assumption that the effects
   5761 	# would be equivalent was wrong.  It would break on at least
   5762 	# Digital Unix and AIX.
   5763 	continue
   5764 	;;
   5765 
   5766       -thread-safe)
   5767 	thread_safe=yes
   5768 	continue
   5769 	;;
   5770 
   5771       -version-info)
   5772 	prev=vinfo
   5773 	continue
   5774 	;;
   5775 
   5776       -version-number)
   5777 	prev=vinfo
   5778 	vinfo_number=yes
   5779 	continue
   5780 	;;
   5781 
   5782       -weak)
   5783         prev=weak
   5784 	continue
   5785 	;;
   5786 
   5787       -Wc,*)
   5788 	func_stripname '-Wc,' '' "$arg"
   5789 	args=$func_stripname_result
   5790 	arg=
   5791 	save_ifs="$IFS"; IFS=','
   5792 	for flag in $args; do
   5793 	  IFS="$save_ifs"
   5794           func_quote_for_eval "$flag"
   5795 	  func_append arg " $func_quote_for_eval_result"
   5796 	  func_append compiler_flags " $func_quote_for_eval_result"
   5797 	done
   5798 	IFS="$save_ifs"
   5799 	func_stripname ' ' '' "$arg"
   5800 	arg=$func_stripname_result
   5801 	;;
   5802 
   5803       -Wl,*)
   5804 	func_stripname '-Wl,' '' "$arg"
   5805 	args=$func_stripname_result
   5806 	arg=
   5807 	save_ifs="$IFS"; IFS=','
   5808 	for flag in $args; do
   5809 	  IFS="$save_ifs"
   5810           func_quote_for_eval "$flag"
   5811 	  func_append arg " $wl$func_quote_for_eval_result"
   5812 	  func_append compiler_flags " $wl$func_quote_for_eval_result"
   5813 	  func_append linker_flags " $func_quote_for_eval_result"
   5814 	done
   5815 	IFS="$save_ifs"
   5816 	func_stripname ' ' '' "$arg"
   5817 	arg=$func_stripname_result
   5818 	;;
   5819 
   5820       -Xcompiler)
   5821 	prev=xcompiler
   5822 	continue
   5823 	;;
   5824 
   5825       -Xlinker)
   5826 	prev=xlinker
   5827 	continue
   5828 	;;
   5829 
   5830       -XCClinker)
   5831 	prev=xcclinker
   5832 	continue
   5833 	;;
   5834 
   5835       # -msg_* for osf cc
   5836       -msg_*)
   5837 	func_quote_for_eval "$arg"
   5838 	arg="$func_quote_for_eval_result"
   5839 	;;
   5840 
   5841       # Flags to be passed through unchanged, with rationale:
   5842       # -64, -mips[0-9]      enable 64-bit mode for the SGI compiler
   5843       # -r[0-9][0-9]*        specify processor for the SGI compiler
   5844       # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
   5845       # +DA*, +DD*           enable 64-bit mode for the HP compiler
   5846       # -q*                  compiler args for the IBM compiler
   5847       # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
   5848       # -F/path              path to uninstalled frameworks, gcc on darwin
   5849       # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
   5850       # @file                GCC response files
   5851       # -tp=*                Portland pgcc target processor selection
   5852       # --sysroot=*          for sysroot support
   5853       # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
   5854       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
   5855       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
   5856       -O*|-flto*|-fwhopr*|-fuse-linker-plugin)
   5857         func_quote_for_eval "$arg"
   5858 	arg="$func_quote_for_eval_result"
   5859         func_append compile_command " $arg"
   5860         func_append finalize_command " $arg"
   5861         func_append compiler_flags " $arg"
   5862         continue
   5863         ;;
   5864 
   5865       # Some other compiler flag.
   5866       -* | +*)
   5867         func_quote_for_eval "$arg"
   5868 	arg="$func_quote_for_eval_result"
   5869 	;;
   5870 
   5871       *.$objext)
   5872 	# A standard object.
   5873 	func_append objs " $arg"
   5874 	;;
   5875 
   5876       *.lo)
   5877 	# A libtool-controlled object.
   5878 
   5879 	# Check to see that this really is a libtool object.
   5880 	if func_lalib_unsafe_p "$arg"; then
   5881 	  pic_object=
   5882 	  non_pic_object=
   5883 
   5884 	  # Read the .lo file
   5885 	  func_source "$arg"
   5886 
   5887 	  if test -z "$pic_object" ||
   5888 	     test -z "$non_pic_object" ||
   5889 	     test "$pic_object" = none &&
   5890 	     test "$non_pic_object" = none; then
   5891 	    func_fatal_error "cannot find name of object for \`$arg'"
   5892 	  fi
   5893 
   5894 	  # Extract subdirectory from the argument.
   5895 	  func_dirname "$arg" "/" ""
   5896 	  xdir="$func_dirname_result"
   5897 
   5898 	  if test "$pic_object" != none; then
   5899 	    # Prepend the subdirectory the object is found in.
   5900 	    pic_object="$xdir$pic_object"
   5901 
   5902 	    if test "$prev" = dlfiles; then
   5903 	      if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
   5904 		func_append dlfiles " $pic_object"
   5905 		prev=
   5906 		continue
   5907 	      else
   5908 		# If libtool objects are unsupported, then we need to preload.
   5909 		prev=dlprefiles
   5910 	      fi
   5911 	    fi
   5912 
   5913 	    # CHECK ME:  I think I busted this.  -Ossama
   5914 	    if test "$prev" = dlprefiles; then
   5915 	      # Preload the old-style object.
   5916 	      func_append dlprefiles " $pic_object"
   5917 	      prev=
   5918 	    fi
   5919 
   5920 	    # A PIC object.
   5921 	    func_append libobjs " $pic_object"
   5922 	    arg="$pic_object"
   5923 	  fi
   5924 
   5925 	  # Non-PIC object.
   5926 	  if test "$non_pic_object" != none; then
   5927 	    # Prepend the subdirectory the object is found in.
   5928 	    non_pic_object="$xdir$non_pic_object"
   5929 
   5930 	    # A standard non-PIC object
   5931 	    func_append non_pic_objects " $non_pic_object"
   5932 	    if test -z "$pic_object" || test "$pic_object" = none ; then
   5933 	      arg="$non_pic_object"
   5934 	    fi
   5935 	  else
   5936 	    # If the PIC object exists, use it instead.
   5937 	    # $xdir was prepended to $pic_object above.
   5938 	    non_pic_object="$pic_object"
   5939 	    func_append non_pic_objects " $non_pic_object"
   5940 	  fi
   5941 	else
   5942 	  # Only an error if not doing a dry-run.
   5943 	  if $opt_dry_run; then
   5944 	    # Extract subdirectory from the argument.
   5945 	    func_dirname "$arg" "/" ""
   5946 	    xdir="$func_dirname_result"
   5947 
   5948 	    func_lo2o "$arg"
   5949 	    pic_object=$xdir$objdir/$func_lo2o_result
   5950 	    non_pic_object=$xdir$func_lo2o_result
   5951 	    func_append libobjs " $pic_object"
   5952 	    func_append non_pic_objects " $non_pic_object"
   5953 	  else
   5954 	    func_fatal_error "\`$arg' is not a valid libtool object"
   5955 	  fi
   5956 	fi
   5957 	;;
   5958 
   5959       *.$libext)
   5960 	# An archive.
   5961 	func_append deplibs " $arg"
   5962 	func_append old_deplibs " $arg"
   5963 	continue
   5964 	;;
   5965 
   5966       *.la)
   5967 	# A libtool-controlled library.
   5968 
   5969 	func_resolve_sysroot "$arg"
   5970 	if test "$prev" = dlfiles; then
   5971 	  # This library was specified with -dlopen.
   5972 	  func_append dlfiles " $func_resolve_sysroot_result"
   5973 	  prev=
   5974 	elif test "$prev" = dlprefiles; then
   5975 	  # The library was specified with -dlpreopen.
   5976 	  func_append dlprefiles " $func_resolve_sysroot_result"
   5977 	  prev=
   5978 	else
   5979 	  func_append deplibs " $func_resolve_sysroot_result"
   5980 	fi
   5981 	continue
   5982 	;;
   5983 
   5984       # Some other compiler argument.
   5985       *)
   5986 	# Unknown arguments in both finalize_command and compile_command need
   5987 	# to be aesthetically quoted because they are evaled later.
   5988 	func_quote_for_eval "$arg"
   5989 	arg="$func_quote_for_eval_result"
   5990 	;;
   5991       esac # arg
   5992 
   5993       # Now actually substitute the argument into the commands.
   5994       if test -n "$arg"; then
   5995 	func_append compile_command " $arg"
   5996 	func_append finalize_command " $arg"
   5997       fi
   5998     done # argument parsing loop
   5999 
   6000     test -n "$prev" && \
   6001       func_fatal_help "the \`$prevarg' option requires an argument"
   6002 
   6003     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
   6004       eval arg=\"$export_dynamic_flag_spec\"
   6005       func_append compile_command " $arg"
   6006       func_append finalize_command " $arg"
   6007     fi
   6008 
   6009     oldlibs=
   6010     # calculate the name of the file, without its directory
   6011     func_basename "$output"
   6012     outputname="$func_basename_result"
   6013     libobjs_save="$libobjs"
   6014 
   6015     if test -n "$shlibpath_var"; then
   6016       # get the directories listed in $shlibpath_var
   6017       eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
   6018     else
   6019       shlib_search_path=
   6020     fi
   6021     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
   6022     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
   6023 
   6024     func_dirname "$output" "/" ""
   6025     output_objdir="$func_dirname_result$objdir"
   6026     func_to_tool_file "$output_objdir/"
   6027     tool_output_objdir=$func_to_tool_file_result
   6028     # Create the object directory.
   6029     func_mkdir_p "$output_objdir"
   6030 
   6031     # Determine the type of output
   6032     case $output in
   6033     "")
   6034       func_fatal_help "you must specify an output file"
   6035       ;;
   6036     *.$libext) linkmode=oldlib ;;
   6037     *.lo | *.$objext) linkmode=obj ;;
   6038     *.la) linkmode=lib ;;
   6039     *) linkmode=prog ;; # Anything else should be a program.
   6040     esac
   6041 
   6042     specialdeplibs=
   6043 
   6044     libs=
   6045     # Find all interdependent deplibs by searching for libraries
   6046     # that are linked more than once (e.g. -la -lb -la)
   6047     for deplib in $deplibs; do
   6048       if $opt_preserve_dup_deps ; then
   6049 	case "$libs " in
   6050 	*" $deplib "*) func_append specialdeplibs " $deplib" ;;
   6051 	esac
   6052       fi
   6053       func_append libs " $deplib"
   6054     done
   6055 
   6056     if test "$linkmode" = lib; then
   6057       libs="$predeps $libs $compiler_lib_search_path $postdeps"
   6058 
   6059       # Compute libraries that are listed more than once in $predeps
   6060       # $postdeps and mark them as special (i.e., whose duplicates are
   6061       # not to be eliminated).
   6062       pre_post_deps=
   6063       if $opt_duplicate_compiler_generated_deps; then
   6064 	for pre_post_dep in $predeps $postdeps; do
   6065 	  case "$pre_post_deps " in
   6066 	  *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
   6067 	  esac
   6068 	  func_append pre_post_deps " $pre_post_dep"
   6069 	done
   6070       fi
   6071       pre_post_deps=
   6072     fi
   6073 
   6074     deplibs=
   6075     newdependency_libs=
   6076     newlib_search_path=
   6077     need_relink=no # whether we're linking any uninstalled libtool libraries
   6078     notinst_deplibs= # not-installed libtool libraries
   6079     notinst_path= # paths that contain not-installed libtool libraries
   6080 
   6081     case $linkmode in
   6082     lib)
   6083 	passes="conv dlpreopen link"
   6084 	for file in $dlfiles $dlprefiles; do
   6085 	  case $file in
   6086 	  *.la) ;;
   6087 	  *)
   6088 	    func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
   6089 	    ;;
   6090 	  esac
   6091 	done
   6092 	;;
   6093     prog)
   6094 	compile_deplibs=
   6095 	finalize_deplibs=
   6096 	alldeplibs=no
   6097 	newdlfiles=
   6098 	newdlprefiles=
   6099 	passes="conv scan dlopen dlpreopen link"
   6100 	;;
   6101     *)  passes="conv"
   6102 	;;
   6103     esac
   6104 
   6105     for pass in $passes; do
   6106       # The preopen pass in lib mode reverses $deplibs; put it back here
   6107       # so that -L comes before libs that need it for instance...
   6108       if test "$linkmode,$pass" = "lib,link"; then
   6109 	## FIXME: Find the place where the list is rebuilt in the wrong
   6110 	##        order, and fix it there properly
   6111         tmp_deplibs=
   6112 	for deplib in $deplibs; do
   6113 	  tmp_deplibs="$deplib $tmp_deplibs"
   6114 	done
   6115 	deplibs="$tmp_deplibs"
   6116       fi
   6117 
   6118       if test "$linkmode,$pass" = "lib,link" ||
   6119 	 test "$linkmode,$pass" = "prog,scan"; then
   6120 	libs="$deplibs"
   6121 	deplibs=
   6122       fi
   6123       if test "$linkmode" = prog; then
   6124 	case $pass in
   6125 	dlopen) libs="$dlfiles" ;;
   6126 	dlpreopen) libs="$dlprefiles" ;;
   6127 	link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
   6128 	esac
   6129       fi
   6130       if test "$linkmode,$pass" = "lib,dlpreopen"; then
   6131 	# Collect and forward deplibs of preopened libtool libs
   6132 	for lib in $dlprefiles; do
   6133 	  # Ignore non-libtool-libs
   6134 	  dependency_libs=
   6135 	  func_resolve_sysroot "$lib"
   6136 	  case $lib in
   6137 	  *.la)	func_source "$func_resolve_sysroot_result" ;;
   6138 	  esac
   6139 
   6140 	  # Collect preopened libtool deplibs, except any this library
   6141 	  # has declared as weak libs
   6142 	  for deplib in $dependency_libs; do
   6143 	    func_basename "$deplib"
   6144             deplib_base=$func_basename_result
   6145 	    case " $weak_libs " in
   6146 	    *" $deplib_base "*) ;;
   6147 	    *) func_append deplibs " $deplib" ;;
   6148 	    esac
   6149 	  done
   6150 	done
   6151 	libs="$dlprefiles"
   6152       fi
   6153       if test "$pass" = dlopen; then
   6154 	# Collect dlpreopened libraries
   6155 	save_deplibs="$deplibs"
   6156 	deplibs=
   6157       fi
   6158 
   6159       for deplib in $libs; do
   6160 	lib=
   6161 	found=no
   6162 	case $deplib in
   6163 	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
   6164         |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
   6165 	  if test "$linkmode,$pass" = "prog,link"; then
   6166 	    compile_deplibs="$deplib $compile_deplibs"
   6167 	    finalize_deplibs="$deplib $finalize_deplibs"
   6168 	  else
   6169 	    func_append compiler_flags " $deplib"
   6170 	    if test "$linkmode" = lib ; then
   6171 		case "$new_inherited_linker_flags " in
   6172 		    *" $deplib "*) ;;
   6173 		    * ) func_append new_inherited_linker_flags " $deplib" ;;
   6174 		esac
   6175 	    fi
   6176 	  fi
   6177 	  continue
   6178 	  ;;
   6179 	-l*)
   6180 	  if test "$linkmode" != lib && test "$linkmode" != prog; then
   6181 	    func_warning "\`-l' is ignored for archives/objects"
   6182 	    continue
   6183 	  fi
   6184 	  func_stripname '-l' '' "$deplib"
   6185 	  name=$func_stripname_result
   6186 	  if test "$linkmode" = lib; then
   6187 	    searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
   6188 	  else
   6189 	    searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
   6190 	  fi
   6191 	  for searchdir in $searchdirs; do
   6192 	    for search_ext in .la $std_shrext .so .a; do
   6193 	      # Search the libtool library
   6194 	      lib="$searchdir/lib${name}${search_ext}"
   6195 	      if test -f "$lib"; then
   6196 		if test "$search_ext" = ".la"; then
   6197 		  found=yes
   6198 		else
   6199 		  found=no
   6200 		fi
   6201 		break 2
   6202 	      fi
   6203 	    done
   6204 	  done
   6205 	  if test "$found" != yes; then
   6206 	    # deplib doesn't seem to be a libtool library
   6207 	    if test "$linkmode,$pass" = "prog,link"; then
   6208 	      compile_deplibs="$deplib $compile_deplibs"
   6209 	      finalize_deplibs="$deplib $finalize_deplibs"
   6210 	    else
   6211 	      deplibs="$deplib $deplibs"
   6212 	      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
   6213 	    fi
   6214 	    continue
   6215 	  else # deplib is a libtool library
   6216 	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
   6217 	    # We need to do some special things here, and not later.
   6218 	    if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
   6219 	      case " $predeps $postdeps " in
   6220 	      *" $deplib "*)
   6221 		if func_lalib_p "$lib"; then
   6222 		  library_names=
   6223 		  old_library=
   6224 		  func_source "$lib"
   6225 		  for l in $old_library $library_names; do
   6226 		    ll="$l"
   6227 		  done
   6228 		  if test "X$ll" = "X$old_library" ; then # only static version available
   6229 		    found=no
   6230 		    func_dirname "$lib" "" "."
   6231 		    ladir="$func_dirname_result"
   6232 		    lib=$ladir/$old_library
   6233 		    if test "$linkmode,$pass" = "prog,link"; then
   6234 		      compile_deplibs="$deplib $compile_deplibs"
   6235 		      finalize_deplibs="$deplib $finalize_deplibs"
   6236 		    else
   6237 		      deplibs="$deplib $deplibs"
   6238 		      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
   6239 		    fi
   6240 		    continue
   6241 		  fi
   6242 		fi
   6243 		;;
   6244 	      *) ;;
   6245 	      esac
   6246 	    fi
   6247 	  fi
   6248 	  ;; # -l
   6249 	*.ltframework)
   6250 	  if test "$linkmode,$pass" = "prog,link"; then
   6251 	    compile_deplibs="$deplib $compile_deplibs"
   6252 	    finalize_deplibs="$deplib $finalize_deplibs"
   6253 	  else
   6254 	    deplibs="$deplib $deplibs"
   6255 	    if test "$linkmode" = lib ; then
   6256 		case "$new_inherited_linker_flags " in
   6257 		    *" $deplib "*) ;;
   6258 		    * ) func_append new_inherited_linker_flags " $deplib" ;;
   6259 		esac
   6260 	    fi
   6261 	  fi
   6262 	  continue
   6263 	  ;;
   6264 	-L*)
   6265 	  case $linkmode in
   6266 	  lib)
   6267 	    deplibs="$deplib $deplibs"
   6268 	    test "$pass" = conv && continue
   6269 	    newdependency_libs="$deplib $newdependency_libs"
   6270 	    func_stripname '-L' '' "$deplib"
   6271 	    func_resolve_sysroot "$func_stripname_result"
   6272 	    func_append newlib_search_path " $func_resolve_sysroot_result"
   6273 	    ;;
   6274 	  prog)
   6275 	    if test "$pass" = conv; then
   6276 	      deplibs="$deplib $deplibs"
   6277 	      continue
   6278 	    fi
   6279 	    if test "$pass" = scan; then
   6280 	      deplibs="$deplib $deplibs"
   6281 	    else
   6282 	      compile_deplibs="$deplib $compile_deplibs"
   6283 	      finalize_deplibs="$deplib $finalize_deplibs"
   6284 	    fi
   6285 	    func_stripname '-L' '' "$deplib"
   6286 	    func_resolve_sysroot "$func_stripname_result"
   6287 	    func_append newlib_search_path " $func_resolve_sysroot_result"
   6288 	    ;;
   6289 	  *)
   6290 	    func_warning "\`-L' is ignored for archives/objects"
   6291 	    ;;
   6292 	  esac # linkmode
   6293 	  continue
   6294 	  ;; # -L
   6295 	-R*)
   6296 	  if test "$pass" = link; then
   6297 	    func_stripname '-R' '' "$deplib"
   6298 	    func_resolve_sysroot "$func_stripname_result"
   6299 	    dir=$func_resolve_sysroot_result
   6300 	    # Make sure the xrpath contains only unique directories.
   6301 	    case "$xrpath " in
   6302 	    *" $dir "*) ;;
   6303 	    *) func_append xrpath " $dir" ;;
   6304 	    esac
   6305 	  fi
   6306 	  deplibs="$deplib $deplibs"
   6307 	  continue
   6308 	  ;;
   6309 	*.la)
   6310 	  func_resolve_sysroot "$deplib"
   6311 	  lib=$func_resolve_sysroot_result
   6312 	  ;;
   6313 	*.$libext)
   6314 	  if test "$pass" = conv; then
   6315 	    deplibs="$deplib $deplibs"
   6316 	    continue
   6317 	  fi
   6318 	  case $linkmode in
   6319 	  lib)
   6320 	    # Linking convenience modules into shared libraries is allowed,
   6321 	    # but linking other static libraries is non-portable.
   6322 	    case " $dlpreconveniencelibs " in
   6323 	    *" $deplib "*) ;;
   6324 	    *)
   6325 	      valid_a_lib=no
   6326 	      case $deplibs_check_method in
   6327 		match_pattern*)
   6328 		  set dummy $deplibs_check_method; shift
   6329 		  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
   6330 		  if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
   6331 		    | $EGREP "$match_pattern_regex" > /dev/null; then
   6332 		    valid_a_lib=yes
   6333 		  fi
   6334 		;;
   6335 		pass_all)
   6336 		  valid_a_lib=yes
   6337 		;;
   6338 	      esac
   6339 	      if test "$valid_a_lib" != yes; then
   6340 		echo
   6341 		$ECHO "*** Warning: Trying to link with static lib archive $deplib."
   6342 		echo "*** I have the capability to make that library automatically link in when"
   6343 		echo "*** you link to this library.  But I can only do this if you have a"
   6344 		echo "*** shared version of the library, which you do not appear to have"
   6345 		echo "*** because the file extensions .$libext of this argument makes me believe"
   6346 		echo "*** that it is just a static archive that I should not use here."
   6347 	      else
   6348 		echo
   6349 		$ECHO "*** Warning: Linking the shared library $output against the"
   6350 		$ECHO "*** static library $deplib is not portable!"
   6351 		deplibs="$deplib $deplibs"
   6352 	      fi
   6353 	      ;;
   6354 	    esac
   6355 	    continue
   6356 	    ;;
   6357 	  prog)
   6358 	    if test "$pass" != link; then
   6359 	      deplibs="$deplib $deplibs"
   6360 	    else
   6361 	      compile_deplibs="$deplib $compile_deplibs"
   6362 	      finalize_deplibs="$deplib $finalize_deplibs"
   6363 	    fi
   6364 	    continue
   6365 	    ;;
   6366 	  esac # linkmode
   6367 	  ;; # *.$libext
   6368 	*.lo | *.$objext)
   6369 	  if test "$pass" = conv; then
   6370 	    deplibs="$deplib $deplibs"
   6371 	  elif test "$linkmode" = prog; then
   6372 	    if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
   6373 	      # If there is no dlopen support or we're linking statically,
   6374 	      # we need to preload.
   6375 	      func_append newdlprefiles " $deplib"
   6376 	      compile_deplibs="$deplib $compile_deplibs"
   6377 	      finalize_deplibs="$deplib $finalize_deplibs"
   6378 	    else
   6379 	      func_append newdlfiles " $deplib"
   6380 	    fi
   6381 	  fi
   6382 	  continue
   6383 	  ;;
   6384 	%DEPLIBS%)
   6385 	  alldeplibs=yes
   6386 	  continue
   6387 	  ;;
   6388 	esac # case $deplib
   6389 
   6390 	if test "$found" = yes || test -f "$lib"; then :
   6391 	else
   6392 	  func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
   6393 	fi
   6394 
   6395 	# Check to see that this really is a libtool archive.
   6396 	func_lalib_unsafe_p "$lib" \
   6397 	  || func_fatal_error "\`$lib' is not a valid libtool archive"
   6398 
   6399 	func_dirname "$lib" "" "."
   6400 	ladir="$func_dirname_result"
   6401 
   6402 	dlname=
   6403 	dlopen=
   6404 	dlpreopen=
   6405 	libdir=
   6406 	library_names=
   6407 	old_library=
   6408 	inherited_linker_flags=
   6409 	# If the library was installed with an old release of libtool,
   6410 	# it will not redefine variables installed, or shouldnotlink
   6411 	installed=yes
   6412 	shouldnotlink=no
   6413 	avoidtemprpath=
   6414 
   6415 
   6416 	# Read the .la file
   6417 	func_source "$lib"
   6418 
   6419 	# Convert "-framework foo" to "foo.ltframework"
   6420 	if test -n "$inherited_linker_flags"; then
   6421 	  tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
   6422 	  for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
   6423 	    case " $new_inherited_linker_flags " in
   6424 	      *" $tmp_inherited_linker_flag "*) ;;
   6425 	      *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
   6426 	    esac
   6427 	  done
   6428 	fi
   6429 	dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
   6430 	if test "$linkmode,$pass" = "lib,link" ||
   6431 	   test "$linkmode,$pass" = "prog,scan" ||
   6432 	   { test "$linkmode" != prog && test "$linkmode" != lib; }; then
   6433 	  test -n "$dlopen" && func_append dlfiles " $dlopen"
   6434 	  test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
   6435 	fi
   6436 
   6437 	if test "$pass" = conv; then
   6438 	  # Only check for convenience libraries
   6439 	  deplibs="$lib $deplibs"
   6440 	  if test -z "$libdir"; then
   6441 	    if test -z "$old_library"; then
   6442 	      func_fatal_error "cannot find name of link library for \`$lib'"
   6443 	    fi
   6444 	    # It is a libtool convenience library, so add in its objects.
   6445 	    func_append convenience " $ladir/$objdir/$old_library"
   6446 	    func_append old_convenience " $ladir/$objdir/$old_library"
   6447 	  elif test "$linkmode" != prog && test "$linkmode" != lib; then
   6448 	    func_fatal_error "\`$lib' is not a convenience library"
   6449 	  fi
   6450 	  tmp_libs=
   6451 	  for deplib in $dependency_libs; do
   6452 	    deplibs="$deplib $deplibs"
   6453 	    if $opt_preserve_dup_deps ; then
   6454 	      case "$tmp_libs " in
   6455 	      *" $deplib "*) func_append specialdeplibs " $deplib" ;;
   6456 	      esac
   6457 	    fi
   6458 	    func_append tmp_libs " $deplib"
   6459 	  done
   6460 	  continue
   6461 	fi # $pass = conv
   6462 
   6463 
   6464 	# Get the name of the library we link against.
   6465 	linklib=
   6466 	if test -n "$old_library" &&
   6467 	   { test "$prefer_static_libs" = yes ||
   6468 	     test "$prefer_static_libs,$installed" = "built,no"; }; then
   6469 	  linklib=$old_library
   6470 	else
   6471 	  for l in $old_library $library_names; do
   6472 	    linklib="$l"
   6473 	  done
   6474 	fi
   6475 	if test -z "$linklib"; then
   6476 	  func_fatal_error "cannot find name of link library for \`$lib'"
   6477 	fi
   6478 
   6479 	# This library was specified with -dlopen.
   6480 	if test "$pass" = dlopen; then
   6481 	  if test -z "$libdir"; then
   6482 	    func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
   6483 	  fi
   6484 	  if test -z "$dlname" ||
   6485 	     test "$dlopen_support" != yes ||
   6486 	     test "$build_libtool_libs" = no; then
   6487 	    # If there is no dlname, no dlopen support or we're linking
   6488 	    # statically, we need to preload.  We also need to preload any
   6489 	    # dependent libraries so libltdl's deplib preloader doesn't
   6490 	    # bomb out in the load deplibs phase.
   6491 	    func_append dlprefiles " $lib $dependency_libs"
   6492 	  else
   6493 	    func_append newdlfiles " $lib"
   6494 	  fi
   6495 	  continue
   6496 	fi # $pass = dlopen
   6497 
   6498 	# We need an absolute path.
   6499 	case $ladir in
   6500 	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
   6501 	*)
   6502 	  abs_ladir=`cd "$ladir" && pwd`
   6503 	  if test -z "$abs_ladir"; then
   6504 	    func_warning "cannot determine absolute directory name of \`$ladir'"
   6505 	    func_warning "passing it literally to the linker, although it might fail"
   6506 	    abs_ladir="$ladir"
   6507 	  fi
   6508 	  ;;
   6509 	esac
   6510 	func_basename "$lib"
   6511 	laname="$func_basename_result"
   6512 
   6513 	# Find the relevant object directory and library name.
   6514 	if test "X$installed" = Xyes; then
   6515 	  if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
   6516 	    func_warning "library \`$lib' was moved."
   6517 	    dir="$ladir"
   6518 	    absdir="$abs_ladir"
   6519 	    libdir="$abs_ladir"
   6520 	  else
   6521 	    dir="$lt_sysroot$libdir"
   6522 	    absdir="$lt_sysroot$libdir"
   6523 	  fi
   6524 	  test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
   6525 	else
   6526 	  if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
   6527 	    dir="$ladir"
   6528 	    absdir="$abs_ladir"
   6529 	    # Remove this search path later
   6530 	    func_append notinst_path " $abs_ladir"
   6531 	  else
   6532 	    dir="$ladir/$objdir"
   6533 	    absdir="$abs_ladir/$objdir"
   6534 	    # Remove this search path later
   6535 	    func_append notinst_path " $abs_ladir"
   6536 	  fi
   6537 	fi # $installed = yes
   6538 	func_stripname 'lib' '.la' "$laname"
   6539 	name=$func_stripname_result
   6540 
   6541 	# This library was specified with -dlpreopen.
   6542 	if test "$pass" = dlpreopen; then
   6543 	  if test -z "$libdir" && test "$linkmode" = prog; then
   6544 	    func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
   6545 	  fi
   6546 	  case "$host" in
   6547 	    # special handling for platforms with PE-DLLs.
   6548 	    *cygwin* | *mingw* | *cegcc* )
   6549 	      # Linker will automatically link against shared library if both
   6550 	      # static and shared are present.  Therefore, ensure we extract
   6551 	      # symbols from the import library if a shared library is present
   6552 	      # (otherwise, the dlopen module name will be incorrect).  We do
   6553 	      # this by putting the import library name into $newdlprefiles.
   6554 	      # We recover the dlopen module name by 'saving' the la file
   6555 	      # name in a special purpose variable, and (later) extracting the
   6556 	      # dlname from the la file.
   6557 	      if test -n "$dlname"; then
   6558 	        func_tr_sh "$dir/$linklib"
   6559 	        eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
   6560 	        func_append newdlprefiles " $dir/$linklib"
   6561 	      else
   6562 	        func_append newdlprefiles " $dir/$old_library"
   6563 	        # Keep a list of preopened convenience libraries to check
   6564 	        # that they are being used correctly in the link pass.
   6565 	        test -z "$libdir" && \
   6566 	          func_append dlpreconveniencelibs " $dir/$old_library"
   6567 	      fi
   6568 	    ;;
   6569 	    * )
   6570 	      # Prefer using a static library (so that no silly _DYNAMIC symbols
   6571 	      # are required to link).
   6572 	      if test -n "$old_library"; then
   6573 	        func_append newdlprefiles " $dir/$old_library"
   6574 	        # Keep a list of preopened convenience libraries to check
   6575 	        # that they are being used correctly in the link pass.
   6576 	        test -z "$libdir" && \
   6577 	          func_append dlpreconveniencelibs " $dir/$old_library"
   6578 	      # Otherwise, use the dlname, so that lt_dlopen finds it.
   6579 	      elif test -n "$dlname"; then
   6580 	        func_append newdlprefiles " $dir/$dlname"
   6581 	      else
   6582 	        func_append newdlprefiles " $dir/$linklib"
   6583 	      fi
   6584 	    ;;
   6585 	  esac
   6586 	fi # $pass = dlpreopen
   6587 
   6588 	if test -z "$libdir"; then
   6589 	  # Link the convenience library
   6590 	  if test "$linkmode" = lib; then
   6591 	    deplibs="$dir/$old_library $deplibs"
   6592 	  elif test "$linkmode,$pass" = "prog,link"; then
   6593 	    compile_deplibs="$dir/$old_library $compile_deplibs"
   6594 	    finalize_deplibs="$dir/$old_library $finalize_deplibs"
   6595 	  else
   6596 	    deplibs="$lib $deplibs" # used for prog,scan pass
   6597 	  fi
   6598 	  continue
   6599 	fi
   6600 
   6601 
   6602 	if test "$linkmode" = prog && test "$pass" != link; then
   6603 	  func_append newlib_search_path " $ladir"
   6604 	  deplibs="$lib $deplibs"
   6605 
   6606 	  linkalldeplibs=no
   6607 	  if test "$link_all_deplibs" != no || test -z "$library_names" ||
   6608 	     test "$build_libtool_libs" = no; then
   6609 	    linkalldeplibs=yes
   6610 	  fi
   6611 
   6612 	  tmp_libs=
   6613 	  for deplib in $dependency_libs; do
   6614 	    case $deplib in
   6615 	    -L*) func_stripname '-L' '' "$deplib"
   6616 	         func_resolve_sysroot "$func_stripname_result"
   6617 	         func_append newlib_search_path " $func_resolve_sysroot_result"
   6618 		 ;;
   6619 	    esac
   6620 	    # Need to link against all dependency_libs?
   6621 	    if test "$linkalldeplibs" = yes; then
   6622 	      deplibs="$deplib $deplibs"
   6623 	    else
   6624 	      # Need to hardcode shared library paths
   6625 	      # or/and link against static libraries
   6626 	      newdependency_libs="$deplib $newdependency_libs"
   6627 	    fi
   6628 	    if $opt_preserve_dup_deps ; then
   6629 	      case "$tmp_libs " in
   6630 	      *" $deplib "*) func_append specialdeplibs " $deplib" ;;
   6631 	      esac
   6632 	    fi
   6633 	    func_append tmp_libs " $deplib"
   6634 	  done # for deplib
   6635 	  continue
   6636 	fi # $linkmode = prog...
   6637 
   6638 	if test "$linkmode,$pass" = "prog,link"; then
   6639 	  if test -n "$library_names" &&
   6640 	     { { test "$prefer_static_libs" = no ||
   6641 	         test "$prefer_static_libs,$installed" = "built,yes"; } ||
   6642 	       test -z "$old_library"; }; then
   6643 	    # We need to hardcode the library path
   6644 	    if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
   6645 	      # Make sure the rpath contains only unique directories.
   6646 	      case "$temp_rpath:" in
   6647 	      *"$absdir:"*) ;;
   6648 	      *) func_append temp_rpath "$absdir:" ;;
   6649 	      esac
   6650 	    fi
   6651 
   6652 	    # Hardcode the library path.
   6653 	    # Skip directories that are in the system default run-time
   6654 	    # search path.
   6655 	    case " $sys_lib_dlsearch_path " in
   6656 	    *" $absdir "*) ;;
   6657 	    *)
   6658 	      case "$compile_rpath " in
   6659 	      *" $absdir "*) ;;
   6660 	      *) func_append compile_rpath " $absdir" ;;
   6661 	      esac
   6662 	      ;;
   6663 	    esac
   6664 	    case " $sys_lib_dlsearch_path " in
   6665 	    *" $libdir "*) ;;
   6666 	    *)
   6667 	      case "$finalize_rpath " in
   6668 	      *" $libdir "*) ;;
   6669 	      *) func_append finalize_rpath " $libdir" ;;
   6670 	      esac
   6671 	      ;;
   6672 	    esac
   6673 	  fi # $linkmode,$pass = prog,link...
   6674 
   6675 	  if test "$alldeplibs" = yes &&
   6676 	     { test "$deplibs_check_method" = pass_all ||
   6677 	       { test "$build_libtool_libs" = yes &&
   6678 		 test -n "$library_names"; }; }; then
   6679 	    # We only need to search for static libraries
   6680 	    continue
   6681 	  fi
   6682 	fi
   6683 
   6684 	link_static=no # Whether the deplib will be linked statically
   6685 	use_static_libs=$prefer_static_libs
   6686 	if test "$use_static_libs" = built && test "$installed" = yes; then
   6687 	  use_static_libs=no
   6688 	fi
   6689 	if test -n "$library_names" &&
   6690 	   { test "$use_static_libs" = no || test -z "$old_library"; }; then
   6691 	  case $host in
   6692 	  *cygwin* | *mingw* | *cegcc*)
   6693 	      # No point in relinking DLLs because paths are not encoded
   6694 	      func_append notinst_deplibs " $lib"
   6695 	      need_relink=no
   6696 	    ;;
   6697 	  *)
   6698 	    if test "$installed" = no; then
   6699 	      func_append notinst_deplibs " $lib"
   6700 	      need_relink=yes
   6701 	    fi
   6702 	    ;;
   6703 	  esac
   6704 	  # This is a shared library
   6705 
   6706 	  # Warn about portability, can't link against -module's on some
   6707 	  # systems (darwin).  Don't bleat about dlopened modules though!
   6708 	  dlopenmodule=""
   6709 	  for dlpremoduletest in $dlprefiles; do
   6710 	    if test "X$dlpremoduletest" = "X$lib"; then
   6711 	      dlopenmodule="$dlpremoduletest"
   6712 	      break
   6713 	    fi
   6714 	  done
   6715 	  if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
   6716 	    echo
   6717 	    if test "$linkmode" = prog; then
   6718 	      $ECHO "*** Warning: Linking the executable $output against the loadable module"
   6719 	    else
   6720 	      $ECHO "*** Warning: Linking the shared library $output against the loadable module"
   6721 	    fi
   6722 	    $ECHO "*** $linklib is not portable!"
   6723 	  fi
   6724 	  if test "$linkmode" = lib &&
   6725 	     test "$hardcode_into_libs" = yes; then
   6726 	    # Hardcode the library path.
   6727 	    # Skip directories that are in the system default run-time
   6728 	    # search path.
   6729 	    case " $sys_lib_dlsearch_path " in
   6730 	    *" $absdir "*) ;;
   6731 	    *)
   6732 	      case "$compile_rpath " in
   6733 	      *" $absdir "*) ;;
   6734 	      *) func_append compile_rpath " $absdir" ;;
   6735 	      esac
   6736 	      ;;
   6737 	    esac
   6738 	    case " $sys_lib_dlsearch_path " in
   6739 	    *" $libdir "*) ;;
   6740 	    *)
   6741 	      case "$finalize_rpath " in
   6742 	      *" $libdir "*) ;;
   6743 	      *) func_append finalize_rpath " $libdir" ;;
   6744 	      esac
   6745 	      ;;
   6746 	    esac
   6747 	  fi
   6748 
   6749 	  if test -n "$old_archive_from_expsyms_cmds"; then
   6750 	    # figure out the soname
   6751 	    set dummy $library_names
   6752 	    shift
   6753 	    realname="$1"
   6754 	    shift
   6755 	    libname=`eval "\\$ECHO \"$libname_spec\""`
   6756 	    # use dlname if we got it. it's perfectly good, no?
   6757 	    if test -n "$dlname"; then
   6758 	      soname="$dlname"
   6759 	    elif test -n "$soname_spec"; then
   6760 	      # bleh windows
   6761 	      case $host in
   6762 	      *cygwin* | mingw* | *cegcc*)
   6763 	        func_arith $current - $age
   6764 		major=$func_arith_result
   6765 		versuffix="-$major"
   6766 		;;
   6767 	      esac
   6768 	      eval soname=\"$soname_spec\"
   6769 	    else
   6770 	      soname="$realname"
   6771 	    fi
   6772 
   6773 	    # Make a new name for the extract_expsyms_cmds to use
   6774 	    soroot="$soname"
   6775 	    func_basename "$soroot"
   6776 	    soname="$func_basename_result"
   6777 	    func_stripname 'lib' '.dll' "$soname"
   6778 	    newlib=libimp-$func_stripname_result.a
   6779 
   6780 	    # If the library has no export list, then create one now
   6781 	    if test -f "$output_objdir/$soname-def"; then :
   6782 	    else
   6783 	      func_verbose "extracting exported symbol list from \`$soname'"
   6784 	      func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
   6785 	    fi
   6786 
   6787 	    # Create $newlib
   6788 	    if test -f "$output_objdir/$newlib"; then :; else
   6789 	      func_verbose "generating import library for \`$soname'"
   6790 	      func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
   6791 	    fi
   6792 	    # make sure the library variables are pointing to the new library
   6793 	    dir=$output_objdir
   6794 	    linklib=$newlib
   6795 	  fi # test -n "$old_archive_from_expsyms_cmds"
   6796 
   6797 	  if test "$linkmode" = prog || test "$opt_mode" != relink; then
   6798 	    add_shlibpath=
   6799 	    add_dir=
   6800 	    add=
   6801 	    lib_linked=yes
   6802 	    case $hardcode_action in
   6803 	    immediate | unsupported)
   6804 	      if test "$hardcode_direct" = no; then
   6805 		add="$dir/$linklib"
   6806 		case $host in
   6807 		  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
   6808 		  *-*-sysv4*uw2*) add_dir="-L$dir" ;;
   6809 		  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
   6810 		    *-*-unixware7*) add_dir="-L$dir" ;;
   6811 		  *-*-darwin* )
   6812 		    # if the lib is a (non-dlopened) module then we can not
   6813 		    # link against it, someone is ignoring the earlier warnings
   6814 		    if /usr/bin/file -L $add 2> /dev/null |
   6815 			 $GREP ": [^:]* bundle" >/dev/null ; then
   6816 		      if test "X$dlopenmodule" != "X$lib"; then
   6817 			$ECHO "*** Warning: lib $linklib is a module, not a shared library"
   6818 			if test -z "$old_library" ; then
   6819 			  echo
   6820 			  echo "*** And there doesn't seem to be a static archive available"
   6821 			  echo "*** The link will probably fail, sorry"
   6822 			else
   6823 			  add="$dir/$old_library"
   6824 			fi
   6825 		      elif test -n "$old_library"; then
   6826 			add="$dir/$old_library"
   6827 		      fi
   6828 		    fi
   6829 		esac
   6830 	      elif test "$hardcode_minus_L" = no; then
   6831 		case $host in
   6832 		*-*-sunos*) add_shlibpath="$dir" ;;
   6833 		esac
   6834 		add_dir="-L$dir"
   6835 		add="-l$name"
   6836 	      elif test "$hardcode_shlibpath_var" = no; then
   6837 		add_shlibpath="$dir"
   6838 		add="-l$name"
   6839 	      else
   6840 		lib_linked=no
   6841 	      fi
   6842 	      ;;
   6843 	    relink)
   6844 	      if test "$hardcode_direct" = yes &&
   6845 	         test "$hardcode_direct_absolute" = no; then
   6846 		add="$dir/$linklib"
   6847 	      elif test "$hardcode_minus_L" = yes; then
   6848 		add_dir="-L$absdir"
   6849 		# Try looking first in the location we're being installed to.
   6850 		if test -n "$inst_prefix_dir"; then
   6851 		  case $libdir in
   6852 		    [\\/]*)
   6853 		      func_append add_dir " -L$inst_prefix_dir$libdir"
   6854 		      ;;
   6855 		  esac
   6856 		fi
   6857 		add="-l$name"
   6858 	      elif test "$hardcode_shlibpath_var" = yes; then
   6859 		add_shlibpath="$dir"
   6860 		add="-l$name"
   6861 	      else
   6862 		lib_linked=no
   6863 	      fi
   6864 	      ;;
   6865 	    *) lib_linked=no ;;
   6866 	    esac
   6867 
   6868 	    if test "$lib_linked" != yes; then
   6869 	      func_fatal_configuration "unsupported hardcode properties"
   6870 	    fi
   6871 
   6872 	    if test -n "$add_shlibpath"; then
   6873 	      case :$compile_shlibpath: in
   6874 	      *":$add_shlibpath:"*) ;;
   6875 	      *) func_append compile_shlibpath "$add_shlibpath:" ;;
   6876 	      esac
   6877 	    fi
   6878 	    if test "$linkmode" = prog; then
   6879 	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
   6880 	      test -n "$add" && compile_deplibs="$add $compile_deplibs"
   6881 	    else
   6882 	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
   6883 	      test -n "$add" && deplibs="$add $deplibs"
   6884 	      if test "$hardcode_direct" != yes &&
   6885 		 test "$hardcode_minus_L" != yes &&
   6886 		 test "$hardcode_shlibpath_var" = yes; then
   6887 		case :$finalize_shlibpath: in
   6888 		*":$libdir:"*) ;;
   6889 		*) func_append finalize_shlibpath "$libdir:" ;;
   6890 		esac
   6891 	      fi
   6892 	    fi
   6893 	  fi
   6894 
   6895 	  if test "$linkmode" = prog || test "$opt_mode" = relink; then
   6896 	    add_shlibpath=
   6897 	    add_dir=
   6898 	    add=
   6899 	    # Finalize command for both is simple: just hardcode it.
   6900 	    if test "$hardcode_direct" = yes &&
   6901 	       test "$hardcode_direct_absolute" = no; then
   6902 	      add="$libdir/$linklib"
   6903 	    elif test "$hardcode_minus_L" = yes; then
   6904 	      add_dir="-L$libdir"
   6905 	      add="-l$name"
   6906 	    elif test "$hardcode_shlibpath_var" = yes; then
   6907 	      case :$finalize_shlibpath: in
   6908 	      *":$libdir:"*) ;;
   6909 	      *) func_append finalize_shlibpath "$libdir:" ;;
   6910 	      esac
   6911 	      add="-l$name"
   6912 	    elif test "$hardcode_automatic" = yes; then
   6913 	      if test -n "$inst_prefix_dir" &&
   6914 		 test -f "$inst_prefix_dir$libdir/$linklib" ; then
   6915 		add="$inst_prefix_dir$libdir/$linklib"
   6916 	      else
   6917 		add="$libdir/$linklib"
   6918 	      fi
   6919 	    else
   6920 	      # We cannot seem to hardcode it, guess we'll fake it.
   6921 	      add_dir="-L$libdir"
   6922 	      # Try looking first in the location we're being installed to.
   6923 	      if test -n "$inst_prefix_dir"; then
   6924 		case $libdir in
   6925 		  [\\/]*)
   6926 		    func_append add_dir " -L$inst_prefix_dir$libdir"
   6927 		    ;;
   6928 		esac
   6929 	      fi
   6930 	      add="-l$name"
   6931 	    fi
   6932 
   6933 	    if test "$linkmode" = prog; then
   6934 	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
   6935 	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
   6936 	    else
   6937 	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
   6938 	      test -n "$add" && deplibs="$add $deplibs"
   6939 	    fi
   6940 	  fi
   6941 	elif test "$linkmode" = prog; then
   6942 	  # Here we assume that one of hardcode_direct or hardcode_minus_L
   6943 	  # is not unsupported.  This is valid on all known static and
   6944 	  # shared platforms.
   6945 	  if test "$hardcode_direct" != unsupported; then
   6946 	    test -n "$old_library" && linklib="$old_library"
   6947 	    compile_deplibs="$dir/$linklib $compile_deplibs"
   6948 	    finalize_deplibs="$dir/$linklib $finalize_deplibs"
   6949 	  else
   6950 	    compile_deplibs="-l$name -L$dir $compile_deplibs"
   6951 	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"
   6952 	  fi
   6953 	elif test "$build_libtool_libs" = yes; then
   6954 	  # Not a shared library
   6955 	  if test "$deplibs_check_method" != pass_all; then
   6956 	    # We're trying link a shared library against a static one
   6957 	    # but the system doesn't support it.
   6958 
   6959 	    # Just print a warning and add the library to dependency_libs so
   6960 	    # that the program can be linked against the static library.
   6961 	    echo
   6962 	    $ECHO "*** Warning: This system can not link to static lib archive $lib."
   6963 	    echo "*** I have the capability to make that library automatically link in when"
   6964 	    echo "*** you link to this library.  But I can only do this if you have a"
   6965 	    echo "*** shared version of the library, which you do not appear to have."
   6966 	    if test "$module" = yes; then
   6967 	      echo "*** But as you try to build a module library, libtool will still create "
   6968 	      echo "*** a static module, that should work as long as the dlopening application"
   6969 	      echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
   6970 	      if test -z "$global_symbol_pipe"; then
   6971 		echo
   6972 		echo "*** However, this would only work if libtool was able to extract symbol"
   6973 		echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
   6974 		echo "*** not find such a program.  So, this module is probably useless."
   6975 		echo "*** \`nm' from GNU binutils and a full rebuild may help."
   6976 	      fi
   6977 	      if test "$build_old_libs" = no; then
   6978 		build_libtool_libs=module
   6979 		build_old_libs=yes
   6980 	      else
   6981 		build_libtool_libs=no
   6982 	      fi
   6983 	    fi
   6984 	  else
   6985 	    deplibs="$dir/$old_library $deplibs"
   6986 	    link_static=yes
   6987 	  fi
   6988 	fi # link shared/static library?
   6989 
   6990 	if test "$linkmode" = lib; then
   6991 	  if test -n "$dependency_libs" &&
   6992 	     { test "$hardcode_into_libs" != yes ||
   6993 	       test "$build_old_libs" = yes ||
   6994 	       test "$link_static" = yes; }; then
   6995 	    # Extract -R from dependency_libs
   6996 	    temp_deplibs=
   6997 	    for libdir in $dependency_libs; do
   6998 	      case $libdir in
   6999 	      -R*) func_stripname '-R' '' "$libdir"
   7000 	           temp_xrpath=$func_stripname_result
   7001 		   case " $xrpath " in
   7002 		   *" $temp_xrpath "*) ;;
   7003 		   *) func_append xrpath " $temp_xrpath";;
   7004 		   esac;;
   7005 	      *) func_append temp_deplibs " $libdir";;
   7006 	      esac
   7007 	    done
   7008 	    dependency_libs="$temp_deplibs"
   7009 	  fi
   7010 
   7011 	  func_append newlib_search_path " $absdir"
   7012 	  # Link against this library
   7013 	  test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
   7014 	  # ... and its dependency_libs
   7015 	  tmp_libs=
   7016 	  for deplib in $dependency_libs; do
   7017 	    newdependency_libs="$deplib $newdependency_libs"
   7018 	    case $deplib in
   7019               -L*) func_stripname '-L' '' "$deplib"
   7020                    func_resolve_sysroot "$func_stripname_result";;
   7021               *) func_resolve_sysroot "$deplib" ;;
   7022             esac
   7023 	    if $opt_preserve_dup_deps ; then
   7024 	      case "$tmp_libs " in
   7025 	      *" $func_resolve_sysroot_result "*)
   7026                 func_append specialdeplibs " $func_resolve_sysroot_result" ;;
   7027 	      esac
   7028 	    fi
   7029 	    func_append tmp_libs " $func_resolve_sysroot_result"
   7030 	  done
   7031 
   7032 	  if test "$link_all_deplibs" != no; then
   7033 	    # Add the search paths of all dependency libraries
   7034 	    for deplib in $dependency_libs; do
   7035 	      path=
   7036 	      case $deplib in
   7037 	      -L*) path="$deplib" ;;
   7038 	      *.la)
   7039 	        func_resolve_sysroot "$deplib"
   7040 	        deplib=$func_resolve_sysroot_result
   7041 	        func_dirname "$deplib" "" "."
   7042 		dir=$func_dirname_result
   7043 		# We need an absolute path.
   7044 		case $dir in
   7045 		[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
   7046 		*)
   7047 		  absdir=`cd "$dir" && pwd`
   7048 		  if test -z "$absdir"; then
   7049 		    func_warning "cannot determine absolute directory name of \`$dir'"
   7050 		    absdir="$dir"
   7051 		  fi
   7052 		  ;;
   7053 		esac
   7054 		if $GREP "^installed=no" $deplib > /dev/null; then
   7055 		case $host in
   7056 		*-*-darwin*)
   7057 		  depdepl=
   7058 		  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
   7059 		  if test -n "$deplibrary_names" ; then
   7060 		    for tmp in $deplibrary_names ; do
   7061 		      depdepl=$tmp
   7062 		    done
   7063 		    if test -f "$absdir/$objdir/$depdepl" ; then
   7064 		      depdepl="$absdir/$objdir/$depdepl"
   7065 		      darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
   7066                       if test -z "$darwin_install_name"; then
   7067                           darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
   7068                       fi
   7069 		      func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
   7070 		      func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
   7071 		      path=
   7072 		    fi
   7073 		  fi
   7074 		  ;;
   7075 		*)
   7076 		  path="-L$absdir/$objdir"
   7077 		  ;;
   7078 		esac
   7079 		else
   7080 		  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
   7081 		  test -z "$libdir" && \
   7082 		    func_fatal_error "\`$deplib' is not a valid libtool archive"
   7083 		  test "$absdir" != "$libdir" && \
   7084 		    func_warning "\`$deplib' seems to be moved"
   7085 
   7086 		  path="-L$absdir"
   7087 		fi
   7088 		;;
   7089 	      esac
   7090 	      case " $deplibs " in
   7091 	      *" $path "*) ;;
   7092 	      *) deplibs="$path $deplibs" ;;
   7093 	      esac
   7094 	    done
   7095 	  fi # link_all_deplibs != no
   7096 	fi # linkmode = lib
   7097       done # for deplib in $libs
   7098       if test "$pass" = link; then
   7099 	if test "$linkmode" = "prog"; then
   7100 	  compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
   7101 	  finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
   7102 	else
   7103 	  compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
   7104 	fi
   7105       fi
   7106       dependency_libs="$newdependency_libs"
   7107       if test "$pass" = dlpreopen; then
   7108 	# Link the dlpreopened libraries before other libraries
   7109 	for deplib in $save_deplibs; do
   7110 	  deplibs="$deplib $deplibs"
   7111 	done
   7112       fi
   7113       if test "$pass" != dlopen; then
   7114 	if test "$pass" != conv; then
   7115 	  # Make sure lib_search_path contains only unique directories.
   7116 	  lib_search_path=
   7117 	  for dir in $newlib_search_path; do
   7118 	    case "$lib_search_path " in
   7119 	    *" $dir "*) ;;
   7120 	    *) func_append lib_search_path " $dir" ;;
   7121 	    esac
   7122 	  done
   7123 	  newlib_search_path=
   7124 	fi
   7125 
   7126 	if test "$linkmode,$pass" != "prog,link"; then
   7127 	  vars="deplibs"
   7128 	else
   7129 	  vars="compile_deplibs finalize_deplibs"
   7130 	fi
   7131 	for var in $vars dependency_libs; do
   7132 	  # Add libraries to $var in reverse order
   7133 	  eval tmp_libs=\"\$$var\"
   7134 	  new_libs=
   7135 	  for deplib in $tmp_libs; do
   7136 	    # FIXME: Pedantically, this is the right thing to do, so
   7137 	    #        that some nasty dependency loop isn't accidentally
   7138 	    #        broken:
   7139 	    #new_libs="$deplib $new_libs"
   7140 	    # Pragmatically, this seems to cause very few problems in
   7141 	    # practice:
   7142 	    case $deplib in
   7143 	    -L*) new_libs="$deplib $new_libs" ;;
   7144 	    -R*) ;;
   7145 	    *)
   7146 	      # And here is the reason: when a library appears more
   7147 	      # than once as an explicit dependence of a library, or
   7148 	      # is implicitly linked in more than once by the
   7149 	      # compiler, it is considered special, and multiple
   7150 	      # occurrences thereof are not removed.  Compare this
   7151 	      # with having the same library being listed as a
   7152 	      # dependency of multiple other libraries: in this case,
   7153 	      # we know (pedantically, we assume) the library does not
   7154 	      # need to be listed more than once, so we keep only the
   7155 	      # last copy.  This is not always right, but it is rare
   7156 	      # enough that we require users that really mean to play
   7157 	      # such unportable linking tricks to link the library
   7158 	      # using -Wl,-lname, so that libtool does not consider it
   7159 	      # for duplicate removal.
   7160 	      case " $specialdeplibs " in
   7161 	      *" $deplib "*) new_libs="$deplib $new_libs" ;;
   7162 	      *)
   7163 		case " $new_libs " in
   7164 		*" $deplib "*) ;;
   7165 		*) new_libs="$deplib $new_libs" ;;
   7166 		esac
   7167 		;;
   7168 	      esac
   7169 	      ;;
   7170 	    esac
   7171 	  done
   7172 	  tmp_libs=
   7173 	  for deplib in $new_libs; do
   7174 	    case $deplib in
   7175 	    -L*)
   7176 	      case " $tmp_libs " in
   7177 	      *" $deplib "*) ;;
   7178 	      *) func_append tmp_libs " $deplib" ;;
   7179 	      esac
   7180 	      ;;
   7181 	    *) func_append tmp_libs " $deplib" ;;
   7182 	    esac
   7183 	  done
   7184 	  eval $var=\"$tmp_libs\"
   7185 	done # for var
   7186       fi
   7187       # Last step: remove runtime libs from dependency_libs
   7188       # (they stay in deplibs)
   7189       tmp_libs=
   7190       for i in $dependency_libs ; do
   7191 	case " $predeps $postdeps $compiler_lib_search_path " in
   7192 	*" $i "*)
   7193 	  i=""
   7194 	  ;;
   7195 	esac
   7196 	if test -n "$i" ; then
   7197 	  func_append tmp_libs " $i"
   7198 	fi
   7199       done
   7200       dependency_libs=$tmp_libs
   7201     done # for pass
   7202     if test "$linkmode" = prog; then
   7203       dlfiles="$newdlfiles"
   7204     fi
   7205     if test "$linkmode" = prog || test "$linkmode" = lib; then
   7206       dlprefiles="$newdlprefiles"
   7207     fi
   7208 
   7209     case $linkmode in
   7210     oldlib)
   7211       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
   7212 	func_warning "\`-dlopen' is ignored for archives"
   7213       fi
   7214 
   7215       case " $deplibs" in
   7216       *\ -l* | *\ -L*)
   7217 	func_warning "\`-l' and \`-L' are ignored for archives" ;;
   7218       esac
   7219 
   7220       test -n "$rpath" && \
   7221 	func_warning "\`-rpath' is ignored for archives"
   7222 
   7223       test -n "$xrpath" && \
   7224 	func_warning "\`-R' is ignored for archives"
   7225 
   7226       test -n "$vinfo" && \
   7227 	func_warning "\`-version-info/-version-number' is ignored for archives"
   7228 
   7229       test -n "$release" && \
   7230 	func_warning "\`-release' is ignored for archives"
   7231 
   7232       test -n "$export_symbols$export_symbols_regex" && \
   7233 	func_warning "\`-export-symbols' is ignored for archives"
   7234 
   7235       # Now set the variables for building old libraries.
   7236       build_libtool_libs=no
   7237       oldlibs="$output"
   7238       func_append objs "$old_deplibs"
   7239       ;;
   7240 
   7241     lib)
   7242       # Make sure we only generate libraries of the form `libNAME.la'.
   7243       case $outputname in
   7244       lib*)
   7245 	func_stripname 'lib' '.la' "$outputname"
   7246 	name=$func_stripname_result
   7247 	eval shared_ext=\"$shrext_cmds\"
   7248 	eval libname=\"$libname_spec\"
   7249 	;;
   7250       *)
   7251 	test "$module" = no && \
   7252 	  func_fatal_help "libtool library \`$output' must begin with \`lib'"
   7253 
   7254 	if test "$need_lib_prefix" != no; then
   7255 	  # Add the "lib" prefix for modules if required
   7256 	  func_stripname '' '.la' "$outputname"
   7257 	  name=$func_stripname_result
   7258 	  eval shared_ext=\"$shrext_cmds\"
   7259 	  eval libname=\"$libname_spec\"
   7260 	else
   7261 	  func_stripname '' '.la' "$outputname"
   7262 	  libname=$func_stripname_result
   7263 	fi
   7264 	;;
   7265       esac
   7266 
   7267       if test -n "$objs"; then
   7268 	if test "$deplibs_check_method" != pass_all; then
   7269 	  func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
   7270 	else
   7271 	  echo
   7272 	  $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
   7273 	  $ECHO "*** objects $objs is not portable!"
   7274 	  func_append libobjs " $objs"
   7275 	fi
   7276       fi
   7277 
   7278       test "$dlself" != no && \
   7279 	func_warning "\`-dlopen self' is ignored for libtool libraries"
   7280 
   7281       set dummy $rpath
   7282       shift
   7283       test "$#" -gt 1 && \
   7284 	func_warning "ignoring multiple \`-rpath's for a libtool library"
   7285 
   7286       install_libdir="$1"
   7287 
   7288       oldlibs=
   7289       if test -z "$rpath"; then
   7290 	if test "$build_libtool_libs" = yes; then
   7291 	  # Building a libtool convenience library.
   7292 	  # Some compilers have problems with a `.al' extension so
   7293 	  # convenience libraries should have the same extension an
   7294 	  # archive normally would.
   7295 	  oldlibs="$output_objdir/$libname.$libext $oldlibs"
   7296 	  build_libtool_libs=convenience
   7297 	  build_old_libs=yes
   7298 	fi
   7299 
   7300 	test -n "$vinfo" && \
   7301 	  func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
   7302 
   7303 	test -n "$release" && \
   7304 	  func_warning "\`-release' is ignored for convenience libraries"
   7305       else
   7306 
   7307 	# Parse the version information argument.
   7308 	save_ifs="$IFS"; IFS=':'
   7309 	set dummy $vinfo 0 0 0
   7310 	shift
   7311 	IFS="$save_ifs"
   7312 
   7313 	test -n "$7" && \
   7314 	  func_fatal_help "too many parameters to \`-version-info'"
   7315 
   7316 	# convert absolute version numbers to libtool ages
   7317 	# this retains compatibility with .la files and attempts
   7318 	# to make the code below a bit more comprehensible
   7319 
   7320 	case $vinfo_number in
   7321 	yes)
   7322 	  number_major="$1"
   7323 	  number_minor="$2"
   7324 	  number_revision="$3"
   7325 	  #
   7326 	  # There are really only two kinds -- those that
   7327 	  # use the current revision as the major version
   7328 	  # and those that subtract age and use age as
   7329 	  # a minor version.  But, then there is irix
   7330 	  # which has an extra 1 added just for fun
   7331 	  #
   7332 	  case $version_type in
   7333 	  # correct linux to gnu/linux during the next big refactor
   7334 	  darwin|linux|osf|windows|none)
   7335 	    func_arith $number_major + $number_minor
   7336 	    current=$func_arith_result
   7337 	    age="$number_minor"
   7338 	    revision="$number_revision"
   7339 	    ;;
   7340 	  freebsd-aout|freebsd-elf|qnx|sunos)
   7341 	    current="$number_major"
   7342 	    revision="$number_minor"
   7343 	    age="0"
   7344 	    ;;
   7345 	  irix|nonstopux)
   7346 	    func_arith $number_major + $number_minor
   7347 	    current=$func_arith_result
   7348 	    age="$number_minor"
   7349 	    revision="$number_minor"
   7350 	    lt_irix_increment=no
   7351 	    ;;
   7352 	  esac
   7353 	  ;;
   7354 	no)
   7355 	  current="$1"
   7356 	  revision="$2"
   7357 	  age="$3"
   7358 	  ;;
   7359 	esac
   7360 
   7361 	# Check that each of the things are valid numbers.
   7362 	case $current in
   7363 	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
   7364 	*)
   7365 	  func_error "CURRENT \`$current' must be a nonnegative integer"
   7366 	  func_fatal_error "\`$vinfo' is not valid version information"
   7367 	  ;;
   7368 	esac
   7369 
   7370 	case $revision in
   7371 	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
   7372 	*)
   7373 	  func_error "REVISION \`$revision' must be a nonnegative integer"
   7374 	  func_fatal_error "\`$vinfo' is not valid version information"
   7375 	  ;;
   7376 	esac
   7377 
   7378 	case $age in
   7379 	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
   7380 	*)
   7381 	  func_error "AGE \`$age' must be a nonnegative integer"
   7382 	  func_fatal_error "\`$vinfo' is not valid version information"
   7383 	  ;;
   7384 	esac
   7385 
   7386 	if test "$age" -gt "$current"; then
   7387 	  func_error "AGE \`$age' is greater than the current interface number \`$current'"
   7388 	  func_fatal_error "\`$vinfo' is not valid version information"
   7389 	fi
   7390 
   7391 	# Calculate the version variables.
   7392 	major=
   7393 	versuffix=
   7394 	verstring=
   7395 	case $version_type in
   7396 	none) ;;
   7397 
   7398 	darwin)
   7399 	  # Like Linux, but with the current version available in
   7400 	  # verstring for coding it into the library header
   7401 	  func_arith $current - $age
   7402 	  major=.$func_arith_result
   7403 	  versuffix="$major.$age.$revision"
   7404 	  # Darwin ld doesn't like 0 for these options...
   7405 	  func_arith $current + 1
   7406 	  minor_current=$func_arith_result
   7407 	  xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
   7408 	  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
   7409 	  ;;
   7410 
   7411 	freebsd-aout)
   7412 	  major=".$current"
   7413 	  versuffix=".$current.$revision";
   7414 	  ;;
   7415 
   7416 	freebsd-elf)
   7417 	  major=".$current"
   7418 	  versuffix=".$current"
   7419 	  ;;
   7420 
   7421 	irix | nonstopux)
   7422 	  if test "X$lt_irix_increment" = "Xno"; then
   7423 	    func_arith $current - $age
   7424 	  else
   7425 	    func_arith $current - $age + 1
   7426 	  fi
   7427 	  major=$func_arith_result
   7428 
   7429 	  case $version_type in
   7430 	    nonstopux) verstring_prefix=nonstopux ;;
   7431 	    *)         verstring_prefix=sgi ;;
   7432 	  esac
   7433 	  verstring="$verstring_prefix$major.$revision"
   7434 
   7435 	  # Add in all the interfaces that we are compatible with.
   7436 	  loop=$revision
   7437 	  while test "$loop" -ne 0; do
   7438 	    func_arith $revision - $loop
   7439 	    iface=$func_arith_result
   7440 	    func_arith $loop - 1
   7441 	    loop=$func_arith_result
   7442 	    verstring="$verstring_prefix$major.$iface:$verstring"
   7443 	  done
   7444 
   7445 	  # Before this point, $major must not contain `.'.
   7446 	  major=.$major
   7447 	  versuffix="$major.$revision"
   7448 	  ;;
   7449 
   7450 	linux) # correct to gnu/linux during the next big refactor
   7451 	  func_arith $current - $age
   7452 	  major=.$func_arith_result
   7453 	  versuffix="$major.$age.$revision"
   7454 	  ;;
   7455 
   7456 	osf)
   7457 	  func_arith $current - $age
   7458 	  major=.$func_arith_result
   7459 	  versuffix=".$current.$age.$revision"
   7460 	  verstring="$current.$age.$revision"
   7461 
   7462 	  # Add in all the interfaces that we are compatible with.
   7463 	  loop=$age
   7464 	  while test "$loop" -ne 0; do
   7465 	    func_arith $current - $loop
   7466 	    iface=$func_arith_result
   7467 	    func_arith $loop - 1
   7468 	    loop=$func_arith_result
   7469 	    verstring="$verstring:${iface}.0"
   7470 	  done
   7471 
   7472 	  # Make executables depend on our current version.
   7473 	  func_append verstring ":${current}.0"
   7474 	  ;;
   7475 
   7476 	qnx)
   7477 	  major=".$current"
   7478 	  versuffix=".$current"
   7479 	  ;;
   7480 
   7481 	sunos)
   7482 	  major=".$current"
   7483 	  versuffix=".$current.$revision"
   7484 	  ;;
   7485 
   7486 	windows)
   7487 	  # Use '-' rather than '.', since we only want one
   7488 	  # extension on DOS 8.3 filesystems.
   7489 	  func_arith $current - $age
   7490 	  major=$func_arith_result
   7491 	  versuffix="-$major"
   7492 	  ;;
   7493 
   7494 	*)
   7495 	  func_fatal_configuration "unknown library version type \`$version_type'"
   7496 	  ;;
   7497 	esac
   7498 
   7499 	# Clear the version info if we defaulted, and they specified a release.
   7500 	if test -z "$vinfo" && test -n "$release"; then
   7501 	  major=
   7502 	  case $version_type in
   7503 	  darwin)
   7504 	    # we can't check for "0.0" in archive_cmds due to quoting
   7505 	    # problems, so we reset it completely
   7506 	    verstring=
   7507 	    ;;
   7508 	  *)
   7509 	    verstring="0.0"
   7510 	    ;;
   7511 	  esac
   7512 	  if test "$need_version" = no; then
   7513 	    versuffix=
   7514 	  else
   7515 	    versuffix=".0.0"
   7516 	  fi
   7517 	fi
   7518 
   7519 	# Remove version info from name if versioning should be avoided
   7520 	if test "$avoid_version" = yes && test "$need_version" = no; then
   7521 	  major=
   7522 	  versuffix=
   7523 	  verstring=""
   7524 	fi
   7525 
   7526 	# Check to see if the archive will have undefined symbols.
   7527 	if test "$allow_undefined" = yes; then
   7528 	  if test "$allow_undefined_flag" = unsupported; then
   7529 	    func_warning "undefined symbols not allowed in $host shared libraries"
   7530 	    build_libtool_libs=no
   7531 	    build_old_libs=yes
   7532 	  fi
   7533 	else
   7534 	  # Don't allow undefined symbols.
   7535 	  allow_undefined_flag="$no_undefined_flag"
   7536 	fi
   7537 
   7538       fi
   7539 
   7540       func_generate_dlsyms "$libname" "$libname" "yes"
   7541       func_append libobjs " $symfileobj"
   7542       test "X$libobjs" = "X " && libobjs=
   7543 
   7544       if test "$opt_mode" != relink; then
   7545 	# Remove our outputs, but don't remove object files since they
   7546 	# may have been created when compiling PIC objects.
   7547 	removelist=
   7548 	tempremovelist=`$ECHO "$output_objdir/*"`
   7549 	for p in $tempremovelist; do
   7550 	  case $p in
   7551 	    *.$objext | *.gcno)
   7552 	       ;;
   7553 	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
   7554 	       if test "X$precious_files_regex" != "X"; then
   7555 		 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
   7556 		 then
   7557 		   continue
   7558 		 fi
   7559 	       fi
   7560 	       func_append removelist " $p"
   7561 	       ;;
   7562 	    *) ;;
   7563 	  esac
   7564 	done
   7565 	test -n "$removelist" && \
   7566 	  func_show_eval "${RM}r \$removelist"
   7567       fi
   7568 
   7569       # Now set the variables for building old libraries.
   7570       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
   7571 	func_append oldlibs " $output_objdir/$libname.$libext"
   7572 
   7573 	# Transform .lo files to .o files.
   7574 	oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
   7575       fi
   7576 
   7577       # Eliminate all temporary directories.
   7578       #for path in $notinst_path; do
   7579       #	lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
   7580       #	deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
   7581       #	dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
   7582       #done
   7583 
   7584       if test -n "$xrpath"; then
   7585 	# If the user specified any rpath flags, then add them.
   7586 	temp_xrpath=
   7587 	for libdir in $xrpath; do
   7588 	  func_replace_sysroot "$libdir"
   7589 	  func_append temp_xrpath " -R$func_replace_sysroot_result"
   7590 	  case "$finalize_rpath " in
   7591 	  *" $libdir "*) ;;
   7592 	  *) func_append finalize_rpath " $libdir" ;;
   7593 	  esac
   7594 	done
   7595 	if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
   7596 	  dependency_libs="$temp_xrpath $dependency_libs"
   7597 	fi
   7598       fi
   7599 
   7600       # Make sure dlfiles contains only unique files that won't be dlpreopened
   7601       old_dlfiles="$dlfiles"
   7602       dlfiles=
   7603       for lib in $old_dlfiles; do
   7604 	case " $dlprefiles $dlfiles " in
   7605 	*" $lib "*) ;;
   7606 	*) func_append dlfiles " $lib" ;;
   7607 	esac
   7608       done
   7609 
   7610       # Make sure dlprefiles contains only unique files
   7611       old_dlprefiles="$dlprefiles"
   7612       dlprefiles=
   7613       for lib in $old_dlprefiles; do
   7614 	case "$dlprefiles " in
   7615 	*" $lib "*) ;;
   7616 	*) func_append dlprefiles " $lib" ;;
   7617 	esac
   7618       done
   7619 
   7620       if test "$build_libtool_libs" = yes; then
   7621 	if test -n "$rpath"; then
   7622 	  case $host in
   7623 	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
   7624 	    # these systems don't actually have a c library (as such)!
   7625 	    ;;
   7626 	  *-*-rhapsody* | *-*-darwin1.[012])
   7627 	    # Rhapsody C library is in the System framework
   7628 	    func_append deplibs " System.ltframework"
   7629 	    ;;
   7630 	  *-*-netbsd*)
   7631 	    # Don't link with libc until the a.out ld.so is fixed.
   7632 	    ;;
   7633 	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
   7634 	    # Do not include libc due to us having libc/libc_r.
   7635 	    ;;
   7636 	  *-*-sco3.2v5* | *-*-sco5v6*)
   7637 	    # Causes problems with __ctype
   7638 	    ;;
   7639 	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
   7640 	    # Compiler inserts libc in the correct place for threads to work
   7641 	    ;;
   7642 	  *)
   7643 	    # Add libc to deplibs on all other systems if necessary.
   7644 	    if test "$build_libtool_need_lc" = "yes"; then
   7645 	      func_append deplibs " -lc"
   7646 	    fi
   7647 	    ;;
   7648 	  esac
   7649 	fi
   7650 
   7651 	# Transform deplibs into only deplibs that can be linked in shared.
   7652 	name_save=$name
   7653 	libname_save=$libname
   7654 	release_save=$release
   7655 	versuffix_save=$versuffix
   7656 	major_save=$major
   7657 	# I'm not sure if I'm treating the release correctly.  I think
   7658 	# release should show up in the -l (ie -lgmp5) so we don't want to
   7659 	# add it in twice.  Is that correct?
   7660 	release=""
   7661 	versuffix=""
   7662 	major=""
   7663 	newdeplibs=
   7664 	droppeddeps=no
   7665 	case $deplibs_check_method in
   7666 	pass_all)
   7667 	  # Don't check for shared/static.  Everything works.
   7668 	  # This might be a little naive.  We might want to check
   7669 	  # whether the library exists or not.  But this is on
   7670 	  # osf3 & osf4 and I'm not really sure... Just
   7671 	  # implementing what was already the behavior.
   7672 	  newdeplibs=$deplibs
   7673 	  ;;
   7674 	test_compile)
   7675 	  # This code stresses the "libraries are programs" paradigm to its
   7676 	  # limits. Maybe even breaks it.  We compile a program, linking it
   7677 	  # against the deplibs as a proxy for the library.  Then we can check
   7678 	  # whether they linked in statically or dynamically with ldd.
   7679 	  $opt_dry_run || $RM conftest.c
   7680 	  cat > conftest.c <<EOF
   7681 	  int main() { return 0; }
   7682 EOF
   7683 	  $opt_dry_run || $RM conftest
   7684 	  if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
   7685 	    ldd_output=`ldd conftest`
   7686 	    for i in $deplibs; do
   7687 	      case $i in
   7688 	      -l*)
   7689 		func_stripname -l '' "$i"
   7690 		name=$func_stripname_result
   7691 		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
   7692 		  case " $predeps $postdeps " in
   7693 		  *" $i "*)
   7694 		    func_append newdeplibs " $i"
   7695 		    i=""
   7696 		    ;;
   7697 		  esac
   7698 		fi
   7699 		if test -n "$i" ; then
   7700 		  libname=`eval "\\$ECHO \"$libname_spec\""`
   7701 		  deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
   7702 		  set dummy $deplib_matches; shift
   7703 		  deplib_match=$1
   7704 		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
   7705 		    func_append newdeplibs " $i"
   7706 		  else
   7707 		    droppeddeps=yes
   7708 		    echo
   7709 		    $ECHO "*** Warning: dynamic linker does not accept needed library $i."
   7710 		    echo "*** I have the capability to make that library automatically link in when"
   7711 		    echo "*** you link to this library.  But I can only do this if you have a"
   7712 		    echo "*** shared version of the library, which I believe you do not have"
   7713 		    echo "*** because a test_compile did reveal that the linker did not use it for"
   7714 		    echo "*** its dynamic dependency list that programs get resolved with at runtime."
   7715 		  fi
   7716 		fi
   7717 		;;
   7718 	      *)
   7719 		func_append newdeplibs " $i"
   7720 		;;
   7721 	      esac
   7722 	    done
   7723 	  else
   7724 	    # Error occurred in the first compile.  Let's try to salvage
   7725 	    # the situation: Compile a separate program for each library.
   7726 	    for i in $deplibs; do
   7727 	      case $i in
   7728 	      -l*)
   7729 		func_stripname -l '' "$i"
   7730 		name=$func_stripname_result
   7731 		$opt_dry_run || $RM conftest
   7732 		if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
   7733 		  ldd_output=`ldd conftest`
   7734 		  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
   7735 		    case " $predeps $postdeps " in
   7736 		    *" $i "*)
   7737 		      func_append newdeplibs " $i"
   7738 		      i=""
   7739 		      ;;
   7740 		    esac
   7741 		  fi
   7742 		  if test -n "$i" ; then
   7743 		    libname=`eval "\\$ECHO \"$libname_spec\""`
   7744 		    deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
   7745 		    set dummy $deplib_matches; shift
   7746 		    deplib_match=$1
   7747 		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
   7748 		      func_append newdeplibs " $i"
   7749 		    else
   7750 		      droppeddeps=yes
   7751 		      echo
   7752 		      $ECHO "*** Warning: dynamic linker does not accept needed library $i."
   7753 		      echo "*** I have the capability to make that library automatically link in when"
   7754 		      echo "*** you link to this library.  But I can only do this if you have a"
   7755 		      echo "*** shared version of the library, which you do not appear to have"
   7756 		      echo "*** because a test_compile did reveal that the linker did not use this one"
   7757 		      echo "*** as a dynamic dependency that programs can get resolved with at runtime."
   7758 		    fi
   7759 		  fi
   7760 		else
   7761 		  droppeddeps=yes
   7762 		  echo
   7763 		  $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
   7764 		  echo "*** make it link in!  You will probably need to install it or some"
   7765 		  echo "*** library that it depends on before this library will be fully"
   7766 		  echo "*** functional.  Installing it before continuing would be even better."
   7767 		fi
   7768 		;;
   7769 	      *)
   7770 		func_append newdeplibs " $i"
   7771 		;;
   7772 	      esac
   7773 	    done
   7774 	  fi
   7775 	  ;;
   7776 	file_magic*)
   7777 	  set dummy $deplibs_check_method; shift
   7778 	  file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
   7779 	  for a_deplib in $deplibs; do
   7780 	    case $a_deplib in
   7781 	    -l*)
   7782 	      func_stripname -l '' "$a_deplib"
   7783 	      name=$func_stripname_result
   7784 	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
   7785 		case " $predeps $postdeps " in
   7786 		*" $a_deplib "*)
   7787 		  func_append newdeplibs " $a_deplib"
   7788 		  a_deplib=""
   7789 		  ;;
   7790 		esac
   7791 	      fi
   7792 	      if test -n "$a_deplib" ; then
   7793 		libname=`eval "\\$ECHO \"$libname_spec\""`
   7794 		if test -n "$file_magic_glob"; then
   7795 		  libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
   7796 		else
   7797 		  libnameglob=$libname
   7798 		fi
   7799 		test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
   7800 		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
   7801 		  if test "$want_nocaseglob" = yes; then
   7802 		    shopt -s nocaseglob
   7803 		    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
   7804 		    $nocaseglob
   7805 		  else
   7806 		    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
   7807 		  fi
   7808 		  for potent_lib in $potential_libs; do
   7809 		      # Follow soft links.
   7810 		      if ls -lLd "$potent_lib" 2>/dev/null |
   7811 			 $GREP " -> " >/dev/null; then
   7812 			continue
   7813 		      fi
   7814 		      # The statement above tries to avoid entering an
   7815 		      # endless loop below, in case of cyclic links.
   7816 		      # We might still enter an endless loop, since a link
   7817 		      # loop can be closed while we follow links,
   7818 		      # but so what?
   7819 		      potlib="$potent_lib"
   7820 		      while test -h "$potlib" 2>/dev/null; do
   7821 			potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
   7822 			case $potliblink in
   7823 			[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
   7824 			*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
   7825 			esac
   7826 		      done
   7827 		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
   7828 			 $SED -e 10q |
   7829 			 $EGREP "$file_magic_regex" > /dev/null; then
   7830 			func_append newdeplibs " $a_deplib"
   7831 			a_deplib=""
   7832 			break 2
   7833 		      fi
   7834 		  done
   7835 		done
   7836 	      fi
   7837 	      if test -n "$a_deplib" ; then
   7838 		droppeddeps=yes
   7839 		echo
   7840 		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
   7841 		echo "*** I have the capability to make that library automatically link in when"
   7842 		echo "*** you link to this library.  But I can only do this if you have a"
   7843 		echo "*** shared version of the library, which you do not appear to have"
   7844 		echo "*** because I did check the linker path looking for a file starting"
   7845 		if test -z "$potlib" ; then
   7846 		  $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
   7847 		else
   7848 		  $ECHO "*** with $libname and none of the candidates passed a file format test"
   7849 		  $ECHO "*** using a file magic. Last file checked: $potlib"
   7850 		fi
   7851 	      fi
   7852 	      ;;
   7853 	    *)
   7854 	      # Add a -L argument.
   7855 	      func_append newdeplibs " $a_deplib"
   7856 	      ;;
   7857 	    esac
   7858 	  done # Gone through all deplibs.
   7859 	  ;;
   7860 	match_pattern*)
   7861 	  set dummy $deplibs_check_method; shift
   7862 	  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
   7863 	  for a_deplib in $deplibs; do
   7864 	    case $a_deplib in
   7865 	    -l*)
   7866 	      func_stripname -l '' "$a_deplib"
   7867 	      name=$func_stripname_result
   7868 	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
   7869 		case " $predeps $postdeps " in
   7870 		*" $a_deplib "*)
   7871 		  func_append newdeplibs " $a_deplib"
   7872 		  a_deplib=""
   7873 		  ;;
   7874 		esac
   7875 	      fi
   7876 	      if test -n "$a_deplib" ; then
   7877 		libname=`eval "\\$ECHO \"$libname_spec\""`
   7878 		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
   7879 		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
   7880 		  for potent_lib in $potential_libs; do
   7881 		    potlib="$potent_lib" # see symlink-check above in file_magic test
   7882 		    if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
   7883 		       $EGREP "$match_pattern_regex" > /dev/null; then
   7884 		      func_append newdeplibs " $a_deplib"
   7885 		      a_deplib=""
   7886 		      break 2
   7887 		    fi
   7888 		  done
   7889 		done
   7890 	      fi
   7891 	      if test -n "$a_deplib" ; then
   7892 		droppeddeps=yes
   7893 		echo
   7894 		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
   7895 		echo "*** I have the capability to make that library automatically link in when"
   7896 		echo "*** you link to this library.  But I can only do this if you have a"
   7897 		echo "*** shared version of the library, which you do not appear to have"
   7898 		echo "*** because I did check the linker path looking for a file starting"
   7899 		if test -z "$potlib" ; then
   7900 		  $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
   7901 		else
   7902 		  $ECHO "*** with $libname and none of the candidates passed a file format test"
   7903 		  $ECHO "*** using a regex pattern. Last file checked: $potlib"
   7904 		fi
   7905 	      fi
   7906 	      ;;
   7907 	    *)
   7908 	      # Add a -L argument.
   7909 	      func_append newdeplibs " $a_deplib"
   7910 	      ;;
   7911 	    esac
   7912 	  done # Gone through all deplibs.
   7913 	  ;;
   7914 	none | unknown | *)
   7915 	  newdeplibs=""
   7916 	  tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
   7917 	  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
   7918 	    for i in $predeps $postdeps ; do
   7919 	      # can't use Xsed below, because $i might contain '/'
   7920 	      tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
   7921 	    done
   7922 	  fi
   7923 	  case $tmp_deplibs in
   7924 	  *[!\	\ ]*)
   7925 	    echo
   7926 	    if test "X$deplibs_check_method" = "Xnone"; then
   7927 	      echo "*** Warning: inter-library dependencies are not supported in this platform."
   7928 	    else
   7929 	      echo "*** Warning: inter-library dependencies are not known to be supported."
   7930 	    fi
   7931 	    echo "*** All declared inter-library dependencies are being dropped."
   7932 	    droppeddeps=yes
   7933 	    ;;
   7934 	  esac
   7935 	  ;;
   7936 	esac
   7937 	versuffix=$versuffix_save
   7938 	major=$major_save
   7939 	release=$release_save
   7940 	libname=$libname_save
   7941 	name=$name_save
   7942 
   7943 	case $host in
   7944 	*-*-rhapsody* | *-*-darwin1.[012])
   7945 	  # On Rhapsody replace the C library with the System framework
   7946 	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
   7947 	  ;;
   7948 	esac
   7949 
   7950 	if test "$droppeddeps" = yes; then
   7951 	  if test "$module" = yes; then
   7952 	    echo
   7953 	    echo "*** Warning: libtool could not satisfy all declared inter-library"
   7954 	    $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
   7955 	    echo "*** a static module, that should work as long as the dlopening"
   7956 	    echo "*** application is linked with the -dlopen flag."
   7957 	    if test -z "$global_symbol_pipe"; then
   7958 	      echo
   7959 	      echo "*** However, this would only work if libtool was able to extract symbol"
   7960 	      echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
   7961 	      echo "*** not find such a program.  So, this module is probably useless."
   7962 	      echo "*** \`nm' from GNU binutils and a full rebuild may help."
   7963 	    fi
   7964 	    if test "$build_old_libs" = no; then
   7965 	      oldlibs="$output_objdir/$libname.$libext"
   7966 	      build_libtool_libs=module
   7967 	      build_old_libs=yes
   7968 	    else
   7969 	      build_libtool_libs=no
   7970 	    fi
   7971 	  else
   7972 	    echo "*** The inter-library dependencies that have been dropped here will be"
   7973 	    echo "*** automatically added whenever a program is linked with this library"
   7974 	    echo "*** or is declared to -dlopen it."
   7975 
   7976 	    if test "$allow_undefined" = no; then
   7977 	      echo
   7978 	      echo "*** Since this library must not contain undefined symbols,"
   7979 	      echo "*** because either the platform does not support them or"
   7980 	      echo "*** it was explicitly requested with -no-undefined,"
   7981 	      echo "*** libtool will only create a static version of it."
   7982 	      if test "$build_old_libs" = no; then
   7983 		oldlibs="$output_objdir/$libname.$libext"
   7984 		build_libtool_libs=module
   7985 		build_old_libs=yes
   7986 	      else
   7987 		build_libtool_libs=no
   7988 	      fi
   7989 	    fi
   7990 	  fi
   7991 	fi
   7992 	# Done checking deplibs!
   7993 	deplibs=$newdeplibs
   7994       fi
   7995       # Time to change all our "foo.ltframework" stuff back to "-framework foo"
   7996       case $host in
   7997 	*-*-darwin*)
   7998 	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
   7999 	  new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
   8000 	  deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
   8001 	  ;;
   8002       esac
   8003 
   8004       # move library search paths that coincide with paths to not yet
   8005       # installed libraries to the beginning of the library search list
   8006       new_libs=
   8007       for path in $notinst_path; do
   8008 	case " $new_libs " in
   8009 	*" -L$path/$objdir "*) ;;
   8010 	*)
   8011 	  case " $deplibs " in
   8012 	  *" -L$path/$objdir "*)
   8013 	    func_append new_libs " -L$path/$objdir" ;;
   8014 	  esac
   8015 	  ;;
   8016 	esac
   8017       done
   8018       for deplib in $deplibs; do
   8019 	case $deplib in
   8020 	-L*)
   8021 	  case " $new_libs " in
   8022 	  *" $deplib "*) ;;
   8023 	  *) func_append new_libs " $deplib" ;;
   8024 	  esac
   8025 	  ;;
   8026 	*) func_append new_libs " $deplib" ;;
   8027 	esac
   8028       done
   8029       deplibs="$new_libs"
   8030 
   8031       # All the library-specific variables (install_libdir is set above).
   8032       library_names=
   8033       old_library=
   8034       dlname=
   8035 
   8036       # Test again, we may have decided not to build it any more
   8037       if test "$build_libtool_libs" = yes; then
   8038 	# Remove ${wl} instances when linking with ld.
   8039 	# FIXME: should test the right _cmds variable.
   8040 	case $archive_cmds in
   8041 	  *\$LD\ *) wl= ;;
   8042         esac
   8043 	if test "$hardcode_into_libs" = yes; then
   8044 	  # Hardcode the library paths
   8045 	  hardcode_libdirs=
   8046 	  dep_rpath=
   8047 	  rpath="$finalize_rpath"
   8048 	  test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
   8049 	  for libdir in $rpath; do
   8050 	    if test -n "$hardcode_libdir_flag_spec"; then
   8051 	      if test -n "$hardcode_libdir_separator"; then
   8052 		func_replace_sysroot "$libdir"
   8053 		libdir=$func_replace_sysroot_result
   8054 		if test -z "$hardcode_libdirs"; then
   8055 		  hardcode_libdirs="$libdir"
   8056 		else
   8057 		  # Just accumulate the unique libdirs.
   8058 		  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
   8059 		  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
   8060 		    ;;
   8061 		  *)
   8062 		    func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
   8063 		    ;;
   8064 		  esac
   8065 		fi
   8066 	      else
   8067 		eval flag=\"$hardcode_libdir_flag_spec\"
   8068 		func_append dep_rpath " $flag"
   8069 	      fi
   8070 	    elif test -n "$runpath_var"; then
   8071 	      case "$perm_rpath " in
   8072 	      *" $libdir "*) ;;
   8073 	      *) func_append perm_rpath " $libdir" ;;
   8074 	      esac
   8075 	    fi
   8076 	  done
   8077 	  # Substitute the hardcoded libdirs into the rpath.
   8078 	  if test -n "$hardcode_libdir_separator" &&
   8079 	     test -n "$hardcode_libdirs"; then
   8080 	    libdir="$hardcode_libdirs"
   8081 	    eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
   8082 	  fi
   8083 	  if test -n "$runpath_var" && test -n "$perm_rpath"; then
   8084 	    # We should set the runpath_var.
   8085 	    rpath=
   8086 	    for dir in $perm_rpath; do
   8087 	      func_append rpath "$dir:"
   8088 	    done
   8089 	    eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
   8090 	  fi
   8091 	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
   8092 	fi
   8093 
   8094 	shlibpath="$finalize_shlibpath"
   8095 	test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
   8096 	if test -n "$shlibpath"; then
   8097 	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
   8098 	fi
   8099 
   8100 	# Get the real and link names of the library.
   8101 	eval shared_ext=\"$shrext_cmds\"
   8102 	eval library_names=\"$library_names_spec\"
   8103 	set dummy $library_names
   8104 	shift
   8105 	realname="$1"
   8106 	shift
   8107 
   8108 	if test -n "$soname_spec"; then
   8109 	  eval soname=\"$soname_spec\"
   8110 	else
   8111 	  soname="$realname"
   8112 	fi
   8113 	if test -z "$dlname"; then
   8114 	  dlname=$soname
   8115 	fi
   8116 
   8117 	lib="$output_objdir/$realname"
   8118 	linknames=
   8119 	for link
   8120 	do
   8121 	  func_append linknames " $link"
   8122 	done
   8123 
   8124 	# Use standard objects if they are pic
   8125 	test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
   8126 	test "X$libobjs" = "X " && libobjs=
   8127 
   8128 	delfiles=
   8129 	if test -n "$export_symbols" && test -n "$include_expsyms"; then
   8130 	  $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
   8131 	  export_symbols="$output_objdir/$libname.uexp"
   8132 	  func_append delfiles " $export_symbols"
   8133 	fi
   8134 
   8135 	orig_export_symbols=
   8136 	case $host_os in
   8137 	cygwin* | mingw* | cegcc*)
   8138 	  if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
   8139 	    # exporting using user supplied symfile
   8140 	    if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
   8141 	      # and it's NOT already a .def file. Must figure out
   8142 	      # which of the given symbols are data symbols and tag
   8143 	      # them as such. So, trigger use of export_symbols_cmds.
   8144 	      # export_symbols gets reassigned inside the "prepare
   8145 	      # the list of exported symbols" if statement, so the
   8146 	      # include_expsyms logic still works.
   8147 	      orig_export_symbols="$export_symbols"
   8148 	      export_symbols=
   8149 	      always_export_symbols=yes
   8150 	    fi
   8151 	  fi
   8152 	  ;;
   8153 	esac
   8154 
   8155 	# Prepare the list of exported symbols
   8156 	if test -z "$export_symbols"; then
   8157 	  if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
   8158 	    func_verbose "generating symbol list for \`$libname.la'"
   8159 	    export_symbols="$output_objdir/$libname.exp"
   8160 	    $opt_dry_run || $RM $export_symbols
   8161 	    cmds=$export_symbols_cmds
   8162 	    save_ifs="$IFS"; IFS='~'
   8163 	    for cmd1 in $cmds; do
   8164 	      IFS="$save_ifs"
   8165 	      # Take the normal branch if the nm_file_list_spec branch
   8166 	      # doesn't work or if tool conversion is not needed.
   8167 	      case $nm_file_list_spec~$to_tool_file_cmd in
   8168 		*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
   8169 		  try_normal_branch=yes
   8170 		  eval cmd=\"$cmd1\"
   8171 		  func_len " $cmd"
   8172 		  len=$func_len_result
   8173 		  ;;
   8174 		*)
   8175 		  try_normal_branch=no
   8176 		  ;;
   8177 	      esac
   8178 	      if test "$try_normal_branch" = yes \
   8179 		 && { test "$len" -lt "$max_cmd_len" \
   8180 		      || test "$max_cmd_len" -le -1; }
   8181 	      then
   8182 		func_show_eval "$cmd" 'exit $?'
   8183 		skipped_export=false
   8184 	      elif test -n "$nm_file_list_spec"; then
   8185 		func_basename "$output"
   8186 		output_la=$func_basename_result
   8187 		save_libobjs=$libobjs
   8188 		save_output=$output
   8189 		output=${output_objdir}/${output_la}.nm
   8190 		func_to_tool_file "$output"
   8191 		libobjs=$nm_file_list_spec$func_to_tool_file_result
   8192 		func_append delfiles " $output"
   8193 		func_verbose "creating $NM input file list: $output"
   8194 		for obj in $save_libobjs; do
   8195 		  func_to_tool_file "$obj"
   8196 		  $ECHO "$func_to_tool_file_result"
   8197 		done > "$output"
   8198 		eval cmd=\"$cmd1\"
   8199 		func_show_eval "$cmd" 'exit $?'
   8200 		output=$save_output
   8201 		libobjs=$save_libobjs
   8202 		skipped_export=false
   8203 	      else
   8204 		# The command line is too long to execute in one step.
   8205 		func_verbose "using reloadable object file for export list..."
   8206 		skipped_export=:
   8207 		# Break out early, otherwise skipped_export may be
   8208 		# set to false by a later but shorter cmd.
   8209 		break
   8210 	      fi
   8211 	    done
   8212 	    IFS="$save_ifs"
   8213 	    if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
   8214 	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
   8215 	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
   8216 	    fi
   8217 	  fi
   8218 	fi
   8219 
   8220 	if test -n "$export_symbols" && test -n "$include_expsyms"; then
   8221 	  tmp_export_symbols="$export_symbols"
   8222 	  test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
   8223 	  $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
   8224 	fi
   8225 
   8226 	if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
   8227 	  # The given exports_symbols file has to be filtered, so filter it.
   8228 	  func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
   8229 	  # FIXME: $output_objdir/$libname.filter potentially contains lots of
   8230 	  # 's' commands which not all seds can handle. GNU sed should be fine
   8231 	  # though. Also, the filter scales superlinearly with the number of
   8232 	  # global variables. join(1) would be nice here, but unfortunately
   8233 	  # isn't a blessed tool.
   8234 	  $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
   8235 	  func_append delfiles " $export_symbols $output_objdir/$libname.filter"
   8236 	  export_symbols=$output_objdir/$libname.def
   8237 	  $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
   8238 	fi
   8239 
   8240 	tmp_deplibs=
   8241 	for test_deplib in $deplibs; do
   8242 	  case " $convenience " in
   8243 	  *" $test_deplib "*) ;;
   8244 	  *)
   8245 	    func_append tmp_deplibs " $test_deplib"
   8246 	    ;;
   8247 	  esac
   8248 	done
   8249 	deplibs="$tmp_deplibs"
   8250 
   8251 	if test -n "$convenience"; then
   8252 	  if test -n "$whole_archive_flag_spec" &&
   8253 	    test "$compiler_needs_object" = yes &&
   8254 	    test -z "$libobjs"; then
   8255 	    # extract the archives, so we have objects to list.
   8256 	    # TODO: could optimize this to just extract one archive.
   8257 	    whole_archive_flag_spec=
   8258 	  fi
   8259 	  if test -n "$whole_archive_flag_spec"; then
   8260 	    save_libobjs=$libobjs
   8261 	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
   8262 	    test "X$libobjs" = "X " && libobjs=
   8263 	  else
   8264 	    gentop="$output_objdir/${outputname}x"
   8265 	    func_append generated " $gentop"
   8266 
   8267 	    func_extract_archives $gentop $convenience
   8268 	    func_append libobjs " $func_extract_archives_result"
   8269 	    test "X$libobjs" = "X " && libobjs=
   8270 	  fi
   8271 	fi
   8272 
   8273 	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
   8274 	  eval flag=\"$thread_safe_flag_spec\"
   8275 	  func_append linker_flags " $flag"
   8276 	fi
   8277 
   8278 	# Make a backup of the uninstalled library when relinking
   8279 	if test "$opt_mode" = relink; then
   8280 	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
   8281 	fi
   8282 
   8283 	# Do each of the archive commands.
   8284 	if test "$module" = yes && test -n "$module_cmds" ; then
   8285 	  if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
   8286 	    eval test_cmds=\"$module_expsym_cmds\"
   8287 	    cmds=$module_expsym_cmds
   8288 	  else
   8289 	    eval test_cmds=\"$module_cmds\"
   8290 	    cmds=$module_cmds
   8291 	  fi
   8292 	else
   8293 	  if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
   8294 	    eval test_cmds=\"$archive_expsym_cmds\"
   8295 	    cmds=$archive_expsym_cmds
   8296 	  else
   8297 	    eval test_cmds=\"$archive_cmds\"
   8298 	    cmds=$archive_cmds
   8299 	  fi
   8300 	fi
   8301 
   8302 	if test "X$skipped_export" != "X:" &&
   8303 	   func_len " $test_cmds" &&
   8304 	   len=$func_len_result &&
   8305 	   test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
   8306 	  :
   8307 	else
   8308 	  # The command line is too long to link in one step, link piecewise
   8309 	  # or, if using GNU ld and skipped_export is not :, use a linker
   8310 	  # script.
   8311 
   8312 	  # Save the value of $output and $libobjs because we want to
   8313 	  # use them later.  If we have whole_archive_flag_spec, we
   8314 	  # want to use save_libobjs as it was before
   8315 	  # whole_archive_flag_spec was expanded, because we can't
   8316 	  # assume the linker understands whole_archive_flag_spec.
   8317 	  # This may have to be revisited, in case too many
   8318 	  # convenience libraries get linked in and end up exceeding
   8319 	  # the spec.
   8320 	  if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
   8321 	    save_libobjs=$libobjs
   8322 	  fi
   8323 	  save_output=$output
   8324 	  func_basename "$output"
   8325 	  output_la=$func_basename_result
   8326 
   8327 	  # Clear the reloadable object creation command queue and
   8328 	  # initialize k to one.
   8329 	  test_cmds=
   8330 	  concat_cmds=
   8331 	  objlist=
   8332 	  last_robj=
   8333 	  k=1
   8334 
   8335 	  if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
   8336 	    output=${output_objdir}/${output_la}.lnkscript
   8337 	    func_verbose "creating GNU ld script: $output"
   8338 	    echo 'INPUT (' > $output
   8339 	    for obj in $save_libobjs
   8340 	    do
   8341 	      func_to_tool_file "$obj"
   8342 	      $ECHO "$func_to_tool_file_result" >> $output
   8343 	    done
   8344 	    echo ')' >> $output
   8345 	    func_append delfiles " $output"
   8346 	    func_to_tool_file "$output"
   8347 	    output=$func_to_tool_file_result
   8348 	  elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
   8349 	    output=${output_objdir}/${output_la}.lnk
   8350 	    func_verbose "creating linker input file list: $output"
   8351 	    : > $output
   8352 	    set x $save_libobjs
   8353 	    shift
   8354 	    firstobj=
   8355 	    if test "$compiler_needs_object" = yes; then
   8356 	      firstobj="$1 "
   8357 	      shift
   8358 	    fi
   8359 	    for obj
   8360 	    do
   8361 	      func_to_tool_file "$obj"
   8362 	      $ECHO "$func_to_tool_file_result" >> $output
   8363 	    done
   8364 	    func_append delfiles " $output"
   8365 	    func_to_tool_file "$output"
   8366 	    output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
   8367 	  else
   8368 	    if test -n "$save_libobjs"; then
   8369 	      func_verbose "creating reloadable object files..."
   8370 	      output=$output_objdir/$output_la-${k}.$objext
   8371 	      eval test_cmds=\"$reload_cmds\"
   8372 	      func_len " $test_cmds"
   8373 	      len0=$func_len_result
   8374 	      len=$len0
   8375 
   8376 	      # Loop over the list of objects to be linked.
   8377 	      for obj in $save_libobjs
   8378 	      do
   8379 		func_len " $obj"
   8380 		func_arith $len + $func_len_result
   8381 		len=$func_arith_result
   8382 		if test "X$objlist" = X ||
   8383 		   test "$len" -lt "$max_cmd_len"; then
   8384 		  func_append objlist " $obj"
   8385 		else
   8386 		  # The command $test_cmds is almost too long, add a
   8387 		  # command to the queue.
   8388 		  if test "$k" -eq 1 ; then
   8389 		    # The first file doesn't have a previous command to add.
   8390 		    reload_objs=$objlist
   8391 		    eval concat_cmds=\"$reload_cmds\"
   8392 		  else
   8393 		    # All subsequent reloadable object files will link in
   8394 		    # the last one created.
   8395 		    reload_objs="$objlist $last_robj"
   8396 		    eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
   8397 		  fi
   8398 		  last_robj=$output_objdir/$output_la-${k}.$objext
   8399 		  func_arith $k + 1
   8400 		  k=$func_arith_result
   8401 		  output=$output_objdir/$output_la-${k}.$objext
   8402 		  objlist=" $obj"
   8403 		  func_len " $last_robj"
   8404 		  func_arith $len0 + $func_len_result
   8405 		  len=$func_arith_result
   8406 		fi
   8407 	      done
   8408 	      # Handle the remaining objects by creating one last
   8409 	      # reloadable object file.  All subsequent reloadable object
   8410 	      # files will link in the last one created.
   8411 	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
   8412 	      reload_objs="$objlist $last_robj"
   8413 	      eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
   8414 	      if test -n "$last_robj"; then
   8415 	        eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
   8416 	      fi
   8417 	      func_append delfiles " $output"
   8418 
   8419 	    else
   8420 	      output=
   8421 	    fi
   8422 
   8423 	    if ${skipped_export-false}; then
   8424 	      func_verbose "generating symbol list for \`$libname.la'"
   8425 	      export_symbols="$output_objdir/$libname.exp"
   8426 	      $opt_dry_run || $RM $export_symbols
   8427 	      libobjs=$output
   8428 	      # Append the command to create the export file.
   8429 	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
   8430 	      eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
   8431 	      if test -n "$last_robj"; then
   8432 		eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
   8433 	      fi
   8434 	    fi
   8435 
   8436 	    test -n "$save_libobjs" &&
   8437 	      func_verbose "creating a temporary reloadable object file: $output"
   8438 
   8439 	    # Loop through the commands generated above and execute them.
   8440 	    save_ifs="$IFS"; IFS='~'
   8441 	    for cmd in $concat_cmds; do
   8442 	      IFS="$save_ifs"
   8443 	      $opt_silent || {
   8444 		  func_quote_for_expand "$cmd"
   8445 		  eval "func_echo $func_quote_for_expand_result"
   8446 	      }
   8447 	      $opt_dry_run || eval "$cmd" || {
   8448 		lt_exit=$?
   8449 
   8450 		# Restore the uninstalled library and exit
   8451 		if test "$opt_mode" = relink; then
   8452 		  ( cd "$output_objdir" && \
   8453 		    $RM "${realname}T" && \
   8454 		    $MV "${realname}U" "$realname" )
   8455 		fi
   8456 
   8457 		exit $lt_exit
   8458 	      }
   8459 	    done
   8460 	    IFS="$save_ifs"
   8461 
   8462 	    if test -n "$export_symbols_regex" && ${skipped_export-false}; then
   8463 	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
   8464 	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
   8465 	    fi
   8466 	  fi
   8467 
   8468           if ${skipped_export-false}; then
   8469 	    if test -n "$export_symbols" && test -n "$include_expsyms"; then
   8470 	      tmp_export_symbols="$export_symbols"
   8471 	      test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
   8472 	      $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
   8473 	    fi
   8474 
   8475 	    if test -n "$orig_export_symbols"; then
   8476 	      # The given exports_symbols file has to be filtered, so filter it.
   8477 	      func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
   8478 	      # FIXME: $output_objdir/$libname.filter potentially contains lots of
   8479 	      # 's' commands which not all seds can handle. GNU sed should be fine
   8480 	      # though. Also, the filter scales superlinearly with the number of
   8481 	      # global variables. join(1) would be nice here, but unfortunately
   8482 	      # isn't a blessed tool.
   8483 	      $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
   8484 	      func_append delfiles " $export_symbols $output_objdir/$libname.filter"
   8485 	      export_symbols=$output_objdir/$libname.def
   8486 	      $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
   8487 	    fi
   8488 	  fi
   8489 
   8490 	  libobjs=$output
   8491 	  # Restore the value of output.
   8492 	  output=$save_output
   8493 
   8494 	  if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
   8495 	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
   8496 	    test "X$libobjs" = "X " && libobjs=
   8497 	  fi
   8498 	  # Expand the library linking commands again to reset the
   8499 	  # value of $libobjs for piecewise linking.
   8500 
   8501 	  # Do each of the archive commands.
   8502 	  if test "$module" = yes && test -n "$module_cmds" ; then
   8503 	    if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
   8504 	      cmds=$module_expsym_cmds
   8505 	    else
   8506 	      cmds=$module_cmds
   8507 	    fi
   8508 	  else
   8509 	    if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
   8510 	      cmds=$archive_expsym_cmds
   8511 	    else
   8512 	      cmds=$archive_cmds
   8513 	    fi
   8514 	  fi
   8515 	fi
   8516 
   8517 	if test -n "$delfiles"; then
   8518 	  # Append the command to remove temporary files to $cmds.
   8519 	  eval cmds=\"\$cmds~\$RM $delfiles\"
   8520 	fi
   8521 
   8522 	# Add any objects from preloaded convenience libraries
   8523 	if test -n "$dlprefiles"; then
   8524 	  gentop="$output_objdir/${outputname}x"
   8525 	  func_append generated " $gentop"
   8526 
   8527 	  func_extract_archives $gentop $dlprefiles
   8528 	  func_append libobjs " $func_extract_archives_result"
   8529 	  test "X$libobjs" = "X " && libobjs=
   8530 	fi
   8531 
   8532 	save_ifs="$IFS"; IFS='~'
   8533 	for cmd in $cmds; do
   8534 	  IFS="$save_ifs"
   8535 	  eval cmd=\"$cmd\"
   8536 	  $opt_silent || {
   8537 	    func_quote_for_expand "$cmd"
   8538 	    eval "func_echo $func_quote_for_expand_result"
   8539 	  }
   8540 	  $opt_dry_run || eval "$cmd" || {
   8541 	    lt_exit=$?
   8542 
   8543 	    # Restore the uninstalled library and exit
   8544 	    if test "$opt_mode" = relink; then
   8545 	      ( cd "$output_objdir" && \
   8546 	        $RM "${realname}T" && \
   8547 		$MV "${realname}U" "$realname" )
   8548 	    fi
   8549 
   8550 	    exit $lt_exit
   8551 	  }
   8552 	done
   8553 	IFS="$save_ifs"
   8554 
   8555 	# Restore the uninstalled library and exit
   8556 	if test "$opt_mode" = relink; then
   8557 	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
   8558 
   8559 	  if test -n "$convenience"; then
   8560 	    if test -z "$whole_archive_flag_spec"; then
   8561 	      func_show_eval '${RM}r "$gentop"'
   8562 	    fi
   8563 	  fi
   8564 
   8565 	  exit $EXIT_SUCCESS
   8566 	fi
   8567 
   8568 	# Create links to the real library.
   8569 	for linkname in $linknames; do
   8570 	  if test "$realname" != "$linkname"; then
   8571 	    func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
   8572 	  fi
   8573 	done
   8574 
   8575 	# If -module or -export-dynamic was specified, set the dlname.
   8576 	if test "$module" = yes || test "$export_dynamic" = yes; then
   8577 	  # On all known operating systems, these are identical.
   8578 	  dlname="$soname"
   8579 	fi
   8580       fi
   8581       ;;
   8582 
   8583     obj)
   8584       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
   8585 	func_warning "\`-dlopen' is ignored for objects"
   8586       fi
   8587 
   8588       case " $deplibs" in
   8589       *\ -l* | *\ -L*)
   8590 	func_warning "\`-l' and \`-L' are ignored for objects" ;;
   8591       esac
   8592 
   8593       test -n "$rpath" && \
   8594 	func_warning "\`-rpath' is ignored for objects"
   8595 
   8596       test -n "$xrpath" && \
   8597 	func_warning "\`-R' is ignored for objects"
   8598 
   8599       test -n "$vinfo" && \
   8600 	func_warning "\`-version-info' is ignored for objects"
   8601 
   8602       test -n "$release" && \
   8603 	func_warning "\`-release' is ignored for objects"
   8604 
   8605       case $output in
   8606       *.lo)
   8607 	test -n "$objs$old_deplibs" && \
   8608 	  func_fatal_error "cannot build library object \`$output' from non-libtool objects"
   8609 
   8610 	libobj=$output
   8611 	func_lo2o "$libobj"
   8612 	obj=$func_lo2o_result
   8613 	;;
   8614       *)
   8615 	libobj=
   8616 	obj="$output"
   8617 	;;
   8618       esac
   8619 
   8620       # Delete the old objects.
   8621       $opt_dry_run || $RM $obj $libobj
   8622 
   8623       # Objects from convenience libraries.  This assumes
   8624       # single-version convenience libraries.  Whenever we create
   8625       # different ones for PIC/non-PIC, this we'll have to duplicate
   8626       # the extraction.
   8627       reload_conv_objs=
   8628       gentop=
   8629       # reload_cmds runs $LD directly, so let us get rid of
   8630       # -Wl from whole_archive_flag_spec and hope we can get by with
   8631       # turning comma into space..
   8632       wl=
   8633 
   8634       if test -n "$convenience"; then
   8635 	if test -n "$whole_archive_flag_spec"; then
   8636 	  eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
   8637 	  reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
   8638 	else
   8639 	  gentop="$output_objdir/${obj}x"
   8640 	  func_append generated " $gentop"
   8641 
   8642 	  func_extract_archives $gentop $convenience
   8643 	  reload_conv_objs="$reload_objs $func_extract_archives_result"
   8644 	fi
   8645       fi
   8646 
   8647       # If we're not building shared, we need to use non_pic_objs
   8648       test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
   8649 
   8650       # Create the old-style object.
   8651       reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
   8652 
   8653       output="$obj"
   8654       func_execute_cmds "$reload_cmds" 'exit $?'
   8655 
   8656       # Exit if we aren't doing a library object file.
   8657       if test -z "$libobj"; then
   8658 	if test -n "$gentop"; then
   8659 	  func_show_eval '${RM}r "$gentop"'
   8660 	fi
   8661 
   8662 	exit $EXIT_SUCCESS
   8663       fi
   8664 
   8665       if test "$build_libtool_libs" != yes; then
   8666 	if test -n "$gentop"; then
   8667 	  func_show_eval '${RM}r "$gentop"'
   8668 	fi
   8669 
   8670 	# Create an invalid libtool object if no PIC, so that we don't
   8671 	# accidentally link it into a program.
   8672 	# $show "echo timestamp > $libobj"
   8673 	# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
   8674 	exit $EXIT_SUCCESS
   8675       fi
   8676 
   8677       if test -n "$pic_flag" || test "$pic_mode" != default; then
   8678 	# Only do commands if we really have different PIC objects.
   8679 	reload_objs="$libobjs $reload_conv_objs"
   8680 	output="$libobj"
   8681 	func_execute_cmds "$reload_cmds" 'exit $?'
   8682       fi
   8683 
   8684       if test -n "$gentop"; then
   8685 	func_show_eval '${RM}r "$gentop"'
   8686       fi
   8687 
   8688       exit $EXIT_SUCCESS
   8689       ;;
   8690 
   8691     prog)
   8692       case $host in
   8693 	*cygwin*) func_stripname '' '.exe' "$output"
   8694 	          output=$func_stripname_result.exe;;
   8695       esac
   8696       test -n "$vinfo" && \
   8697 	func_warning "\`-version-info' is ignored for programs"
   8698 
   8699       test -n "$release" && \
   8700 	func_warning "\`-release' is ignored for programs"
   8701 
   8702       test "$preload" = yes \
   8703         && test "$dlopen_support" = unknown \
   8704 	&& test "$dlopen_self" = unknown \
   8705 	&& test "$dlopen_self_static" = unknown && \
   8706 	  func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
   8707 
   8708       case $host in
   8709       *-*-rhapsody* | *-*-darwin1.[012])
   8710 	# On Rhapsody replace the C library is the System framework
   8711 	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
   8712 	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
   8713 	;;
   8714       esac
   8715 
   8716       case $host in
   8717       *-*-darwin*)
   8718 	# Don't allow lazy linking, it breaks C++ global constructors
   8719 	# But is supposedly fixed on 10.4 or later (yay!).
   8720 	if test "$tagname" = CXX ; then
   8721 	  case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
   8722 	    10.[0123])
   8723 	      func_append compile_command " ${wl}-bind_at_load"
   8724 	      func_append finalize_command " ${wl}-bind_at_load"
   8725 	    ;;
   8726 	  esac
   8727 	fi
   8728 	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
   8729 	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
   8730 	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
   8731 	;;
   8732       esac
   8733 
   8734 
   8735       # move library search paths that coincide with paths to not yet
   8736       # installed libraries to the beginning of the library search list
   8737       new_libs=
   8738       for path in $notinst_path; do
   8739 	case " $new_libs " in
   8740 	*" -L$path/$objdir "*) ;;
   8741 	*)
   8742 	  case " $compile_deplibs " in
   8743 	  *" -L$path/$objdir "*)
   8744 	    func_append new_libs " -L$path/$objdir" ;;
   8745 	  esac
   8746 	  ;;
   8747 	esac
   8748       done
   8749       for deplib in $compile_deplibs; do
   8750 	case $deplib in
   8751 	-L*)
   8752 	  case " $new_libs " in
   8753 	  *" $deplib "*) ;;
   8754 	  *) func_append new_libs " $deplib" ;;
   8755 	  esac
   8756 	  ;;
   8757 	*) func_append new_libs " $deplib" ;;
   8758 	esac
   8759       done
   8760       compile_deplibs="$new_libs"
   8761 
   8762 
   8763       func_append compile_command " $compile_deplibs"
   8764       func_append finalize_command " $finalize_deplibs"
   8765 
   8766       if test -n "$rpath$xrpath"; then
   8767 	# If the user specified any rpath flags, then add them.
   8768 	for libdir in $rpath $xrpath; do
   8769 	  # This is the magic to use -rpath.
   8770 	  case "$finalize_rpath " in
   8771 	  *" $libdir "*) ;;
   8772 	  *) func_append finalize_rpath " $libdir" ;;
   8773 	  esac
   8774 	done
   8775       fi
   8776 
   8777       # Now hardcode the library paths
   8778       rpath=
   8779       hardcode_libdirs=
   8780       for libdir in $compile_rpath $finalize_rpath; do
   8781 	if test -n "$hardcode_libdir_flag_spec"; then
   8782 	  if test -n "$hardcode_libdir_separator"; then
   8783 	    if test -z "$hardcode_libdirs"; then
   8784 	      hardcode_libdirs="$libdir"
   8785 	    else
   8786 	      # Just accumulate the unique libdirs.
   8787 	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
   8788 	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
   8789 		;;
   8790 	      *)
   8791 		func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
   8792 		;;
   8793 	      esac
   8794 	    fi
   8795 	  else
   8796 	    eval flag=\"$hardcode_libdir_flag_spec\"
   8797 	    func_append rpath " $flag"
   8798 	  fi
   8799 	elif test -n "$runpath_var"; then
   8800 	  case "$perm_rpath " in
   8801 	  *" $libdir "*) ;;
   8802 	  *) func_append perm_rpath " $libdir" ;;
   8803 	  esac
   8804 	fi
   8805 	case $host in
   8806 	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
   8807 	  testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
   8808 	  case :$dllsearchpath: in
   8809 	  *":$libdir:"*) ;;
   8810 	  ::) dllsearchpath=$libdir;;
   8811 	  *) func_append dllsearchpath ":$libdir";;
   8812 	  esac
   8813 	  case :$dllsearchpath: in
   8814 	  *":$testbindir:"*) ;;
   8815 	  ::) dllsearchpath=$testbindir;;
   8816 	  *) func_append dllsearchpath ":$testbindir";;
   8817 	  esac
   8818 	  ;;
   8819 	esac
   8820       done
   8821       # Substitute the hardcoded libdirs into the rpath.
   8822       if test -n "$hardcode_libdir_separator" &&
   8823 	 test -n "$hardcode_libdirs"; then
   8824 	libdir="$hardcode_libdirs"
   8825 	eval rpath=\" $hardcode_libdir_flag_spec\"
   8826       fi
   8827       compile_rpath="$rpath"
   8828 
   8829       rpath=
   8830       hardcode_libdirs=
   8831       for libdir in $finalize_rpath; do
   8832 	if test -n "$hardcode_libdir_flag_spec"; then
   8833 	  if test -n "$hardcode_libdir_separator"; then
   8834 	    if test -z "$hardcode_libdirs"; then
   8835 	      hardcode_libdirs="$libdir"
   8836 	    else
   8837 	      # Just accumulate the unique libdirs.
   8838 	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
   8839 	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
   8840 		;;
   8841 	      *)
   8842 		func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
   8843 		;;
   8844 	      esac
   8845 	    fi
   8846 	  else
   8847 	    eval flag=\"$hardcode_libdir_flag_spec\"
   8848 	    func_append rpath " $flag"
   8849 	  fi
   8850 	elif test -n "$runpath_var"; then
   8851 	  case "$finalize_perm_rpath " in
   8852 	  *" $libdir "*) ;;
   8853 	  *) func_append finalize_perm_rpath " $libdir" ;;
   8854 	  esac
   8855 	fi
   8856       done
   8857       # Substitute the hardcoded libdirs into the rpath.
   8858       if test -n "$hardcode_libdir_separator" &&
   8859 	 test -n "$hardcode_libdirs"; then
   8860 	libdir="$hardcode_libdirs"
   8861 	eval rpath=\" $hardcode_libdir_flag_spec\"
   8862       fi
   8863       finalize_rpath="$rpath"
   8864 
   8865       if test -n "$libobjs" && test "$build_old_libs" = yes; then
   8866 	# Transform all the library objects into standard objects.
   8867 	compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
   8868 	finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
   8869       fi
   8870 
   8871       func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
   8872 
   8873       # template prelinking step
   8874       if test -n "$prelink_cmds"; then
   8875 	func_execute_cmds "$prelink_cmds" 'exit $?'
   8876       fi
   8877 
   8878       wrappers_required=yes
   8879       case $host in
   8880       *cegcc* | *mingw32ce*)
   8881         # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
   8882         wrappers_required=no
   8883         ;;
   8884       *cygwin* | *mingw* )
   8885         if test "$build_libtool_libs" != yes; then
   8886           wrappers_required=no
   8887         fi
   8888         ;;
   8889       *)
   8890         if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
   8891           wrappers_required=no
   8892         fi
   8893         ;;
   8894       esac
   8895       if test "$wrappers_required" = no; then
   8896 	# Replace the output file specification.
   8897 	compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
   8898 	link_command="$compile_command$compile_rpath"
   8899 
   8900 	# We have no uninstalled library dependencies, so finalize right now.
   8901 	exit_status=0
   8902 	func_show_eval "$link_command" 'exit_status=$?'
   8903 
   8904 	if test -n "$postlink_cmds"; then
   8905 	  func_to_tool_file "$output"
   8906 	  postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
   8907 	  func_execute_cmds "$postlink_cmds" 'exit $?'
   8908 	fi
   8909 
   8910 	# Delete the generated files.
   8911 	if test -f "$output_objdir/${outputname}S.${objext}"; then
   8912 	  func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
   8913 	fi
   8914 
   8915 	exit $exit_status
   8916       fi
   8917 
   8918       if test -n "$compile_shlibpath$finalize_shlibpath"; then
   8919 	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
   8920       fi
   8921       if test -n "$finalize_shlibpath"; then
   8922 	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
   8923       fi
   8924 
   8925       compile_var=
   8926       finalize_var=
   8927       if test -n "$runpath_var"; then
   8928 	if test -n "$perm_rpath"; then
   8929 	  # We should set the runpath_var.
   8930 	  rpath=
   8931 	  for dir in $perm_rpath; do
   8932 	    func_append rpath "$dir:"
   8933 	  done
   8934 	  compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
   8935 	fi
   8936 	if test -n "$finalize_perm_rpath"; then
   8937 	  # We should set the runpath_var.
   8938 	  rpath=
   8939 	  for dir in $finalize_perm_rpath; do
   8940 	    func_append rpath "$dir:"
   8941 	  done
   8942 	  finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
   8943 	fi
   8944       fi
   8945 
   8946       if test "$no_install" = yes; then
   8947 	# We don't need to create a wrapper script.
   8948 	link_command="$compile_var$compile_command$compile_rpath"
   8949 	# Replace the output file specification.
   8950 	link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
   8951 	# Delete the old output file.
   8952 	$opt_dry_run || $RM $output
   8953 	# Link the executable and exit
   8954 	func_show_eval "$link_command" 'exit $?'
   8955 
   8956 	if test -n "$postlink_cmds"; then
   8957 	  func_to_tool_file "$output"
   8958 	  postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
   8959 	  func_execute_cmds "$postlink_cmds" 'exit $?'
   8960 	fi
   8961 
   8962 	exit $EXIT_SUCCESS
   8963       fi
   8964 
   8965       if test "$hardcode_action" = relink; then
   8966 	# Fast installation is not supported
   8967 	link_command="$compile_var$compile_command$compile_rpath"
   8968 	relink_command="$finalize_var$finalize_command$finalize_rpath"
   8969 
   8970 	func_warning "this platform does not like uninstalled shared libraries"
   8971 	func_warning "\`$output' will be relinked during installation"
   8972       else
   8973 	if test "$fast_install" != no; then
   8974 	  link_command="$finalize_var$compile_command$finalize_rpath"
   8975 	  if test "$fast_install" = yes; then
   8976 	    relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
   8977 	  else
   8978 	    # fast_install is set to needless
   8979 	    relink_command=
   8980 	  fi
   8981 	else
   8982 	  link_command="$compile_var$compile_command$compile_rpath"
   8983 	  relink_command="$finalize_var$finalize_command$finalize_rpath"
   8984 	fi
   8985       fi
   8986 
   8987       # Replace the output file specification.
   8988       link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
   8989 
   8990       # Delete the old output files.
   8991       $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
   8992 
   8993       func_show_eval "$link_command" 'exit $?'
   8994 
   8995       if test -n "$postlink_cmds"; then
   8996 	func_to_tool_file "$output_objdir/$outputname"
   8997 	postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
   8998 	func_execute_cmds "$postlink_cmds" 'exit $?'
   8999       fi
   9000 
   9001       # Now create the wrapper script.
   9002       func_verbose "creating $output"
   9003 
   9004       # Quote the relink command for shipping.
   9005       if test -n "$relink_command"; then
   9006 	# Preserve any variables that may affect compiler behavior
   9007 	for var in $variables_saved_for_relink; do
   9008 	  if eval test -z \"\${$var+set}\"; then
   9009 	    relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
   9010 	  elif eval var_value=\$$var; test -z "$var_value"; then
   9011 	    relink_command="$var=; export $var; $relink_command"
   9012 	  else
   9013 	    func_quote_for_eval "$var_value"
   9014 	    relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
   9015 	  fi
   9016 	done
   9017 	relink_command="(cd `pwd`; $relink_command)"
   9018 	relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
   9019       fi
   9020 
   9021       # Only actually do things if not in dry run mode.
   9022       $opt_dry_run || {
   9023 	# win32 will think the script is a binary if it has
   9024 	# a .exe suffix, so we strip it off here.
   9025 	case $output in
   9026 	  *.exe) func_stripname '' '.exe' "$output"
   9027 	         output=$func_stripname_result ;;
   9028 	esac
   9029 	# test for cygwin because mv fails w/o .exe extensions
   9030 	case $host in
   9031 	  *cygwin*)
   9032 	    exeext=.exe
   9033 	    func_stripname '' '.exe' "$outputname"
   9034 	    outputname=$func_stripname_result ;;
   9035 	  *) exeext= ;;
   9036 	esac
   9037 	case $host in
   9038 	  *cygwin* | *mingw* )
   9039 	    func_dirname_and_basename "$output" "" "."
   9040 	    output_name=$func_basename_result
   9041 	    output_path=$func_dirname_result
   9042 	    cwrappersource="$output_path/$objdir/lt-$output_name.c"
   9043 	    cwrapper="$output_path/$output_name.exe"
   9044 	    $RM $cwrappersource $cwrapper
   9045 	    trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
   9046 
   9047 	    func_emit_cwrapperexe_src > $cwrappersource
   9048 
   9049 	    # The wrapper executable is built using the $host compiler,
   9050 	    # because it contains $host paths and files. If cross-
   9051 	    # compiling, it, like the target executable, must be
   9052 	    # executed on the $host or under an emulation environment.
   9053 	    $opt_dry_run || {
   9054 	      $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
   9055 	      $STRIP $cwrapper
   9056 	    }
   9057 
   9058 	    # Now, create the wrapper script for func_source use:
   9059 	    func_ltwrapper_scriptname $cwrapper
   9060 	    $RM $func_ltwrapper_scriptname_result
   9061 	    trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
   9062 	    $opt_dry_run || {
   9063 	      # note: this script will not be executed, so do not chmod.
   9064 	      if test "x$build" = "x$host" ; then
   9065 		$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
   9066 	      else
   9067 		func_emit_wrapper no > $func_ltwrapper_scriptname_result
   9068 	      fi
   9069 	    }
   9070 	  ;;
   9071 	  * )
   9072 	    $RM $output
   9073 	    trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
   9074 
   9075 	    func_emit_wrapper no > $output
   9076 	    chmod +x $output
   9077 	  ;;
   9078 	esac
   9079       }
   9080       exit $EXIT_SUCCESS
   9081       ;;
   9082     esac
   9083 
   9084     # See if we need to build an old-fashioned archive.
   9085     for oldlib in $oldlibs; do
   9086 
   9087       if test "$build_libtool_libs" = convenience; then
   9088 	oldobjs="$libobjs_save $symfileobj"
   9089 	addlibs="$convenience"
   9090 	build_libtool_libs=no
   9091       else
   9092 	if test "$build_libtool_libs" = module; then
   9093 	  oldobjs="$libobjs_save"
   9094 	  build_libtool_libs=no
   9095 	else
   9096 	  oldobjs="$old_deplibs $non_pic_objects"
   9097 	  if test "$preload" = yes && test -f "$symfileobj"; then
   9098 	    func_append oldobjs " $symfileobj"
   9099 	  fi
   9100 	fi
   9101 	addlibs="$old_convenience"
   9102       fi
   9103 
   9104       if test -n "$addlibs"; then
   9105 	gentop="$output_objdir/${outputname}x"
   9106 	func_append generated " $gentop"
   9107 
   9108 	func_extract_archives $gentop $addlibs
   9109 	func_append oldobjs " $func_extract_archives_result"
   9110       fi
   9111 
   9112       # Do each command in the archive commands.
   9113       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
   9114 	cmds=$old_archive_from_new_cmds
   9115       else
   9116 
   9117 	# Add any objects from preloaded convenience libraries
   9118 	if test -n "$dlprefiles"; then
   9119 	  gentop="$output_objdir/${outputname}x"
   9120 	  func_append generated " $gentop"
   9121 
   9122 	  func_extract_archives $gentop $dlprefiles
   9123 	  func_append oldobjs " $func_extract_archives_result"
   9124 	fi
   9125 
   9126 	# POSIX demands no paths to be encoded in archives.  We have
   9127 	# to avoid creating archives with duplicate basenames if we
   9128 	# might have to extract them afterwards, e.g., when creating a
   9129 	# static archive out of a convenience library, or when linking
   9130 	# the entirety of a libtool archive into another (currently
   9131 	# not supported by libtool).
   9132 	if (for obj in $oldobjs
   9133 	    do
   9134 	      func_basename "$obj"
   9135 	      $ECHO "$func_basename_result"
   9136 	    done | sort | sort -uc >/dev/null 2>&1); then
   9137 	  :
   9138 	else
   9139 	  echo "copying selected object files to avoid basename conflicts..."
   9140 	  gentop="$output_objdir/${outputname}x"
   9141 	  func_append generated " $gentop"
   9142 	  func_mkdir_p "$gentop"
   9143 	  save_oldobjs=$oldobjs
   9144 	  oldobjs=
   9145 	  counter=1
   9146 	  for obj in $save_oldobjs
   9147 	  do
   9148 	    func_basename "$obj"
   9149 	    objbase="$func_basename_result"
   9150 	    case " $oldobjs " in
   9151 	    " ") oldobjs=$obj ;;
   9152 	    *[\ /]"$objbase "*)
   9153 	      while :; do
   9154 		# Make sure we don't pick an alternate name that also
   9155 		# overlaps.
   9156 		newobj=lt$counter-$objbase
   9157 		func_arith $counter + 1
   9158 		counter=$func_arith_result
   9159 		case " $oldobjs " in
   9160 		*[\ /]"$newobj "*) ;;
   9161 		*) if test ! -f "$gentop/$newobj"; then break; fi ;;
   9162 		esac
   9163 	      done
   9164 	      func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
   9165 	      func_append oldobjs " $gentop/$newobj"
   9166 	      ;;
   9167 	    *) func_append oldobjs " $obj" ;;
   9168 	    esac
   9169 	  done
   9170 	fi
   9171 	func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
   9172 	tool_oldlib=$func_to_tool_file_result
   9173 	eval cmds=\"$old_archive_cmds\"
   9174 
   9175 	func_len " $cmds"
   9176 	len=$func_len_result
   9177 	if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
   9178 	  cmds=$old_archive_cmds
   9179 	elif test -n "$archiver_list_spec"; then
   9180 	  func_verbose "using command file archive linking..."
   9181 	  for obj in $oldobjs
   9182 	  do
   9183 	    func_to_tool_file "$obj"
   9184 	    $ECHO "$func_to_tool_file_result"
   9185 	  done > $output_objdir/$libname.libcmd
   9186 	  func_to_tool_file "$output_objdir/$libname.libcmd"
   9187 	  oldobjs=" $archiver_list_spec$func_to_tool_file_result"
   9188 	  cmds=$old_archive_cmds
   9189 	else
   9190 	  # the command line is too long to link in one step, link in parts
   9191 	  func_verbose "using piecewise archive linking..."
   9192 	  save_RANLIB=$RANLIB
   9193 	  RANLIB=:
   9194 	  objlist=
   9195 	  concat_cmds=
   9196 	  save_oldobjs=$oldobjs
   9197 	  oldobjs=
   9198 	  # Is there a better way of finding the last object in the list?
   9199 	  for obj in $save_oldobjs
   9200 	  do
   9201 	    last_oldobj=$obj
   9202 	  done
   9203 	  eval test_cmds=\"$old_archive_cmds\"
   9204 	  func_len " $test_cmds"
   9205 	  len0=$func_len_result
   9206 	  len=$len0
   9207 	  for obj in $save_oldobjs
   9208 	  do
   9209 	    func_len " $obj"
   9210 	    func_arith $len + $func_len_result
   9211 	    len=$func_arith_result
   9212 	    func_append objlist " $obj"
   9213 	    if test "$len" -lt "$max_cmd_len"; then
   9214 	      :
   9215 	    else
   9216 	      # the above command should be used before it gets too long
   9217 	      oldobjs=$objlist
   9218 	      if test "$obj" = "$last_oldobj" ; then
   9219 		RANLIB=$save_RANLIB
   9220 	      fi
   9221 	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
   9222 	      eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
   9223 	      objlist=
   9224 	      len=$len0
   9225 	    fi
   9226 	  done
   9227 	  RANLIB=$save_RANLIB
   9228 	  oldobjs=$objlist
   9229 	  if test "X$oldobjs" = "X" ; then
   9230 	    eval cmds=\"\$concat_cmds\"
   9231 	  else
   9232 	    eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
   9233 	  fi
   9234 	fi
   9235       fi
   9236       func_execute_cmds "$cmds" 'exit $?'
   9237     done
   9238 
   9239     test -n "$generated" && \
   9240       func_show_eval "${RM}r$generated"
   9241 
   9242     # Now create the libtool archive.
   9243     case $output in
   9244     *.la)
   9245       old_library=
   9246       test "$build_old_libs" = yes && old_library="$libname.$libext"
   9247       func_verbose "creating $output"
   9248 
   9249       # Preserve any variables that may affect compiler behavior
   9250       for var in $variables_saved_for_relink; do
   9251 	if eval test -z \"\${$var+set}\"; then
   9252 	  relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
   9253 	elif eval var_value=\$$var; test -z "$var_value"; then
   9254 	  relink_command="$var=; export $var; $relink_command"
   9255 	else
   9256 	  func_quote_for_eval "$var_value"
   9257 	  relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
   9258 	fi
   9259       done
   9260       # Quote the link command for shipping.
   9261       relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
   9262       relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
   9263       if test "$hardcode_automatic" = yes ; then
   9264 	relink_command=
   9265       fi
   9266 
   9267       # Only create the output if not a dry run.
   9268       $opt_dry_run || {
   9269 	for installed in no yes; do
   9270 	  if test "$installed" = yes; then
   9271 	    if test -z "$install_libdir"; then
   9272 	      break
   9273 	    fi
   9274 	    output="$output_objdir/$outputname"i
   9275 	    # Replace all uninstalled libtool libraries with the installed ones
   9276 	    newdependency_libs=
   9277 	    for deplib in $dependency_libs; do
   9278 	      case $deplib in
   9279 	      *.la)
   9280 		func_basename "$deplib"
   9281 		name="$func_basename_result"
   9282 		func_resolve_sysroot "$deplib"
   9283 		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
   9284 		test -z "$libdir" && \
   9285 		  func_fatal_error "\`$deplib' is not a valid libtool archive"
   9286 		func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
   9287 		;;
   9288 	      -L*)
   9289 		func_stripname -L '' "$deplib"
   9290 		func_replace_sysroot "$func_stripname_result"
   9291 		func_append newdependency_libs " -L$func_replace_sysroot_result"
   9292 		;;
   9293 	      -R*)
   9294 		func_stripname -R '' "$deplib"
   9295 		func_replace_sysroot "$func_stripname_result"
   9296 		func_append newdependency_libs " -R$func_replace_sysroot_result"
   9297 		;;
   9298 	      *) func_append newdependency_libs " $deplib" ;;
   9299 	      esac
   9300 	    done
   9301 	    dependency_libs="$newdependency_libs"
   9302 	    newdlfiles=
   9303 
   9304 	    for lib in $dlfiles; do
   9305 	      case $lib in
   9306 	      *.la)
   9307 	        func_basename "$lib"
   9308 		name="$func_basename_result"
   9309 		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
   9310 		test -z "$libdir" && \
   9311 		  func_fatal_error "\`$lib' is not a valid libtool archive"
   9312 		func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
   9313 		;;
   9314 	      *) func_append newdlfiles " $lib" ;;
   9315 	      esac
   9316 	    done
   9317 	    dlfiles="$newdlfiles"
   9318 	    newdlprefiles=
   9319 	    for lib in $dlprefiles; do
   9320 	      case $lib in
   9321 	      *.la)
   9322 		# Only pass preopened files to the pseudo-archive (for
   9323 		# eventual linking with the app. that links it) if we
   9324 		# didn't already link the preopened objects directly into
   9325 		# the library:
   9326 		func_basename "$lib"
   9327 		name="$func_basename_result"
   9328 		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
   9329 		test -z "$libdir" && \
   9330 		  func_fatal_error "\`$lib' is not a valid libtool archive"
   9331 		func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
   9332 		;;
   9333 	      esac
   9334 	    done
   9335 	    dlprefiles="$newdlprefiles"
   9336 	  else
   9337 	    newdlfiles=
   9338 	    for lib in $dlfiles; do
   9339 	      case $lib in
   9340 		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
   9341 		*) abs=`pwd`"/$lib" ;;
   9342 	      esac
   9343 	      func_append newdlfiles " $abs"
   9344 	    done
   9345 	    dlfiles="$newdlfiles"
   9346 	    newdlprefiles=
   9347 	    for lib in $dlprefiles; do
   9348 	      case $lib in
   9349 		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
   9350 		*) abs=`pwd`"/$lib" ;;
   9351 	      esac
   9352 	      func_append newdlprefiles " $abs"
   9353 	    done
   9354 	    dlprefiles="$newdlprefiles"
   9355 	  fi
   9356 	  $RM $output
   9357 	  # place dlname in correct position for cygwin
   9358 	  # In fact, it would be nice if we could use this code for all target
   9359 	  # systems that can't hard-code library paths into their executables
   9360 	  # and that have no shared library path variable independent of PATH,
   9361 	  # but it turns out we can't easily determine that from inspecting
   9362 	  # libtool variables, so we have to hard-code the OSs to which it
   9363 	  # applies here; at the moment, that means platforms that use the PE
   9364 	  # object format with DLL files.  See the long comment at the top of
   9365 	  # tests/bindir.at for full details.
   9366 	  tdlname=$dlname
   9367 	  case $host,$output,$installed,$module,$dlname in
   9368 	    *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
   9369 	      # If a -bindir argument was supplied, place the dll there.
   9370 	      if test "x$bindir" != x ;
   9371 	      then
   9372 		func_relative_path "$install_libdir" "$bindir"
   9373 		tdlname=$func_relative_path_result$dlname
   9374 	      else
   9375 		# Otherwise fall back on heuristic.
   9376 		tdlname=../bin/$dlname
   9377 	      fi
   9378 	      ;;
   9379 	  esac
   9380 	  $ECHO > $output "\
   9381 # $outputname - a libtool library file
   9382 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
   9383 #
   9384 # Please DO NOT delete this file!
   9385 # It is necessary for linking the library.
   9386 
   9387 # The name that we can dlopen(3).
   9388 dlname='$tdlname'
   9389 
   9390 # Names of this library.
   9391 library_names='$library_names'
   9392 
   9393 # The name of the static archive.
   9394 old_library='$old_library'
   9395 
   9396 # Linker flags that can not go in dependency_libs.
   9397 inherited_linker_flags='$new_inherited_linker_flags'
   9398 
   9399 # Libraries that this one depends upon.
   9400 dependency_libs='$dependency_libs'
   9401 
   9402 # Names of additional weak libraries provided by this library
   9403 weak_library_names='$weak_libs'
   9404 
   9405 # Version information for $libname.
   9406 current=$current
   9407 age=$age
   9408 revision=$revision
   9409 
   9410 # Is this an already installed library?
   9411 installed=$installed
   9412 
   9413 # Should we warn about portability when linking against -modules?
   9414 shouldnotlink=$module
   9415 
   9416 # Files to dlopen/dlpreopen
   9417 dlopen='$dlfiles'
   9418 dlpreopen='$dlprefiles'
   9419 
   9420 # Directory that this library needs to be installed in:
   9421 libdir='$install_libdir'"
   9422 	  if test "$installed" = no && test "$need_relink" = yes; then
   9423 	    $ECHO >> $output "\
   9424 relink_command=\"$relink_command\""
   9425 	  fi
   9426 	done
   9427       }
   9428 
   9429       # Do a symbolic link so that the libtool archive can be found in
   9430       # LD_LIBRARY_PATH before the program is installed.
   9431       func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
   9432       ;;
   9433     esac
   9434     exit $EXIT_SUCCESS
   9435 }
   9436 
   9437 { test "$opt_mode" = link || test "$opt_mode" = relink; } &&
   9438     func_mode_link ${1+"$@"}
   9439 
   9440 
   9441 # func_mode_uninstall arg...
   9442 func_mode_uninstall ()
   9443 {
   9444     $opt_debug
   9445     RM="$nonopt"
   9446     files=
   9447     rmforce=
   9448     exit_status=0
   9449 
   9450     # This variable tells wrapper scripts just to set variables rather
   9451     # than running their programs.
   9452     libtool_install_magic="$magic"
   9453 
   9454     for arg
   9455     do
   9456       case $arg in
   9457       -f) func_append RM " $arg"; rmforce=yes ;;
   9458       -*) func_append RM " $arg" ;;
   9459       *) func_append files " $arg" ;;
   9460       esac
   9461     done
   9462 
   9463     test -z "$RM" && \
   9464       func_fatal_help "you must specify an RM program"
   9465 
   9466     rmdirs=
   9467 
   9468     for file in $files; do
   9469       func_dirname "$file" "" "."
   9470       dir="$func_dirname_result"
   9471       if test "X$dir" = X.; then
   9472 	odir="$objdir"
   9473       else
   9474 	odir="$dir/$objdir"
   9475       fi
   9476       func_basename "$file"
   9477       name="$func_basename_result"
   9478       test "$opt_mode" = uninstall && odir="$dir"
   9479 
   9480       # Remember odir for removal later, being careful to avoid duplicates
   9481       if test "$opt_mode" = clean; then
   9482 	case " $rmdirs " in
   9483 	  *" $odir "*) ;;
   9484 	  *) func_append rmdirs " $odir" ;;
   9485 	esac
   9486       fi
   9487 
   9488       # Don't error if the file doesn't exist and rm -f was used.
   9489       if { test -L "$file"; } >/dev/null 2>&1 ||
   9490 	 { test -h "$file"; } >/dev/null 2>&1 ||
   9491 	 test -f "$file"; then
   9492 	:
   9493       elif test -d "$file"; then
   9494 	exit_status=1
   9495 	continue
   9496       elif test "$rmforce" = yes; then
   9497 	continue
   9498       fi
   9499 
   9500       rmfiles="$file"
   9501 
   9502       case $name in
   9503       *.la)
   9504 	# Possibly a libtool archive, so verify it.
   9505 	if func_lalib_p "$file"; then
   9506 	  func_source $dir/$name
   9507 
   9508 	  # Delete the libtool libraries and symlinks.
   9509 	  for n in $library_names; do
   9510 	    func_append rmfiles " $odir/$n"
   9511 	  done
   9512 	  test -n "$old_library" && func_append rmfiles " $odir/$old_library"
   9513 
   9514 	  case "$opt_mode" in
   9515 	  clean)
   9516 	    case " $library_names " in
   9517 	    *" $dlname "*) ;;
   9518 	    *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
   9519 	    esac
   9520 	    test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
   9521 	    ;;
   9522 	  uninstall)
   9523 	    if test -n "$library_names"; then
   9524 	      # Do each command in the postuninstall commands.
   9525 	      func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
   9526 	    fi
   9527 
   9528 	    if test -n "$old_library"; then
   9529 	      # Do each command in the old_postuninstall commands.
   9530 	      func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
   9531 	    fi
   9532 	    # FIXME: should reinstall the best remaining shared library.
   9533 	    ;;
   9534 	  esac
   9535 	fi
   9536 	;;
   9537 
   9538       *.lo)
   9539 	# Possibly a libtool object, so verify it.
   9540 	if func_lalib_p "$file"; then
   9541 
   9542 	  # Read the .lo file
   9543 	  func_source $dir/$name
   9544 
   9545 	  # Add PIC object to the list of files to remove.
   9546 	  if test -n "$pic_object" &&
   9547 	     test "$pic_object" != none; then
   9548 	    func_append rmfiles " $dir/$pic_object"
   9549 	  fi
   9550 
   9551 	  # Add non-PIC object to the list of files to remove.
   9552 	  if test -n "$non_pic_object" &&
   9553 	     test "$non_pic_object" != none; then
   9554 	    func_append rmfiles " $dir/$non_pic_object"
   9555 	  fi
   9556 	fi
   9557 	;;
   9558 
   9559       *)
   9560 	if test "$opt_mode" = clean ; then
   9561 	  noexename=$name
   9562 	  case $file in
   9563 	  *.exe)
   9564 	    func_stripname '' '.exe' "$file"
   9565 	    file=$func_stripname_result
   9566 	    func_stripname '' '.exe' "$name"
   9567 	    noexename=$func_stripname_result
   9568 	    # $file with .exe has already been added to rmfiles,
   9569 	    # add $file without .exe
   9570 	    func_append rmfiles " $file"
   9571 	    ;;
   9572 	  esac
   9573 	  # Do a test to see if this is a libtool program.
   9574 	  if func_ltwrapper_p "$file"; then
   9575 	    if func_ltwrapper_executable_p "$file"; then
   9576 	      func_ltwrapper_scriptname "$file"
   9577 	      relink_command=
   9578 	      func_source $func_ltwrapper_scriptname_result
   9579 	      func_append rmfiles " $func_ltwrapper_scriptname_result"
   9580 	    else
   9581 	      relink_command=
   9582 	      func_source $dir/$noexename
   9583 	    fi
   9584 
   9585 	    # note $name still contains .exe if it was in $file originally
   9586 	    # as does the version of $file that was added into $rmfiles
   9587 	    func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
   9588 	    if test "$fast_install" = yes && test -n "$relink_command"; then
   9589 	      func_append rmfiles " $odir/lt-$name"
   9590 	    fi
   9591 	    if test "X$noexename" != "X$name" ; then
   9592 	      func_append rmfiles " $odir/lt-${noexename}.c"
   9593 	    fi
   9594 	  fi
   9595 	fi
   9596 	;;
   9597       esac
   9598       func_show_eval "$RM $rmfiles" 'exit_status=1'
   9599     done
   9600 
   9601     # Try to remove the ${objdir}s in the directories where we deleted files
   9602     for dir in $rmdirs; do
   9603       if test -d "$dir"; then
   9604 	func_show_eval "rmdir $dir >/dev/null 2>&1"
   9605       fi
   9606     done
   9607 
   9608     exit $exit_status
   9609 }
   9610 
   9611 { test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
   9612     func_mode_uninstall ${1+"$@"}
   9613 
   9614 test -z "$opt_mode" && {
   9615   help="$generic_help"
   9616   func_fatal_help "you must specify a MODE"
   9617 }
   9618 
   9619 test -z "$exec_cmd" && \
   9620   func_fatal_help "invalid operation mode \`$opt_mode'"
   9621 
   9622 if test -n "$exec_cmd"; then
   9623   eval exec "$exec_cmd"
   9624   exit $EXIT_FAILURE
   9625 fi
   9626 
   9627 exit $exit_status
   9628 
   9629 
   9630 # The TAGs below are defined such that we never get into a situation
   9631 # in which we disable both kinds of libraries.  Given conflicting
   9632 # choices, we go for a static library, that is the most portable,
   9633 # since we can't tell whether shared libraries were disabled because
   9634 # the user asked for that or because the platform doesn't support
   9635 # them.  This is particularly important on AIX, because we don't
   9636 # support having both static and shared libraries enabled at the same
   9637 # time on that platform, so we default to a shared-only configuration.
   9638 # If a disable-shared tag is given, we'll fallback to a static-only
   9639 # configuration.  But we'll never go from static-only to shared-only.
   9640 
   9641 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
   9642 build_libtool_libs=no
   9643 build_old_libs=yes
   9644 # ### END LIBTOOL TAG CONFIG: disable-shared
   9645 
   9646 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
   9647 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
   9648 # ### END LIBTOOL TAG CONFIG: disable-static
   9649 
   9650 # Local Variables:
   9651 # mode:shell-script
   9652 # sh-indentation:2
   9653 # End:
   9654 # vi:sw=2
   9655 
   9656