ltmain.sh

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