ltmain.sh

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