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