contrib/file/ltmain.sh

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