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