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