ltmain.sh

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