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