release/src/router/glib/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.3293
  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="grep -E"}
 140 : ${FGREP="grep -F"}
 141 : ${GREP="grep"}
 142 : ${LN_S="ln -s"}
 143 : ${MAKE="make"}
 144 : ${MKDIR="mkdir"}
 145 : ${MV="mv -f"}
 146 : ${RM="rm -f"}
 147 : ${SED="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 "OpenWrt-$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 "OpenWrt-$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 "OpenWrt-$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       # Strip any trailing slash from the destination.
2957       func_stripname '' '/' "$libdir"
2958       destlibdir=$func_stripname_result
2959
2960       func_stripname '' '/' "$destdir"
2961       s_destdir=$func_stripname_result
2962
2963           # Determine the prefix the user has applied to our future dir.
2964           inst_prefix_dir=`$ECHO "X$s_destdir" | $Xsed -e "s%$destlibdir\$%%"`
2965
2966           # Don't allow the user to place us outside of our expected
2967           # location b/c this prevents finding dependent libraries that
2968           # are installed to the same prefix.
2969           # At present, this check doesn't affect windows .dll's that
2970           # are installed into $libdir/../bin (currently, that works fine)
2971           # but it's something to keep an eye on.
2972           test "$inst_prefix_dir" = "$destdir" && \
2973             func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2974
2975           if test -n "$inst_prefix_dir"; then
2976             # Stick the inst_prefix_dir data into the link command.
2977             relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2978           else
2979             relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2980           fi
2981
2982           relink_command=`$ECHO "$relink_command" | $SED "s%-L[[:space:]]*/lib[^[:space:]]*%%"`
2983           relink_command=`$ECHO "$relink_command" | $SED "s%-L[[:space:]]*/usr/lib[^[:space:]]*%%"`
2984
2985           func_warning "relinking \`$file'"
2986           func_show_eval "$relink_command" \
2987             'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2988         fi
2989
2990         # See the names of the shared library.
2991         set dummy $library_names; shift
2992         if test -n "$1"; then
2993           realname="$1"
2994           shift
2995
2996           srcname="$realname"
2997           test -n "$relink_command" && srcname="$realname"T
2998
2999           # Install the shared library and build the symlinks.
3000           func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
3001               'exit $?'
3002           tstripme="$stripme"
3003           case $host_os in
3004           cygwin* | mingw* | pw32* | cegcc*)
3005             case $realname in
3006             *.dll.a)
3007               tstripme=""
3008               ;;
3009             esac
3010             ;;
3011           esac
3012           if test -n "$tstripme" && test -n "$striplib"; then
3013             func_show_eval "$striplib $destdir/$realname" 'exit $?'
3014           fi
3015
3016           if test "$#" -gt 0; then
3017             # Delete the old symlinks, and create new ones.
3018             # Try `ln -sf' first, because the `ln' binary might depend on
3019             # the symlink we replace!  Solaris /bin/ln does not understand -f,
3020             # so we also need to try rm && ln -s.
3021             for linkname
3022             do
3023               test "$linkname" != "$realname" \
3024                 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
3025             done
3026           fi
3027
3028           # Do each command in the postinstall commands.
3029           lib="$destdir/$realname"
3030           func_execute_cmds "$postinstall_cmds" 'exit $?'
3031         fi
3032
3033         # Install the pseudo-library for information purposes.
3034         func_basename "$file"
3035         name="$func_basename_result"
3036         instname="$dir/$name"i
3037         func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
3038
3039         # Maybe install the static library, too.
3040         test -n "$old_library" && func_append staticlibs " $dir/$old_library"
3041         ;;
3042
3043       *.lo)
3044         # Install (i.e. copy) a libtool object.
3045
3046         # Figure out destination file name, if it wasn't already specified.
3047         if test -n "$destname"; then
3048           destfile="$destdir/$destname"
3049         else
3050           func_basename "$file"
3051           destfile="$func_basename_result"
3052           destfile="$destdir/$destfile"
3053         fi
3054
3055         # Deduce the name of the destination old-style object file.
3056         case $destfile in
3057         *.lo)
3058           func_lo2o "$destfile"
3059           staticdest=$func_lo2o_result
3060           ;;
3061         *.$objext)
3062           staticdest="$destfile"
3063           destfile=
3064           ;;
3065         *)
3066           func_fatal_help "cannot copy a libtool object to \`$destfile'"
3067           ;;
3068         esac
3069
3070         # Install the libtool object if requested.
3071         test -n "$destfile" && \
3072           func_show_eval "$install_prog $file $destfile" 'exit $?'
3073
3074         # Install the old object if enabled.
3075         if test "$build_old_libs" = yes; then
3076           # Deduce the name of the old-style object file.
3077           func_lo2o "$file"
3078           staticobj=$func_lo2o_result
3079           func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
3080         fi
3081         exit $EXIT_SUCCESS
3082         ;;
3083
3084       *)
3085         # Figure out destination file name, if it wasn't already specified.
3086         if test -n "$destname"; then
3087           destfile="$destdir/$destname"
3088         else
3089           func_basename "$file"
3090           destfile="$func_basename_result"
3091           destfile="$destdir/$destfile"
3092         fi
3093
3094         # If the file is missing, and there is a .exe on the end, strip it
3095         # because it is most likely a libtool script we actually want to
3096         # install
3097         stripped_ext=""
3098         case $file in
3099           *.exe)
3100             if test ! -f "$file"; then
3101               func_stripname '' '.exe' "$file"
3102               file=$func_stripname_result
3103               stripped_ext=".exe"
3104             fi
3105             ;;
3106         esac
3107
3108         # Do a test to see if this is really a libtool program.
3109         case $host in
3110         *cygwin* | *mingw*)
3111             if func_ltwrapper_executable_p "$file"; then
3112               func_ltwrapper_scriptname "$file"
3113               wrapper=$func_ltwrapper_scriptname_result
3114             else
3115               func_stripname '' '.exe' "$file"
3116               wrapper=$func_stripname_result
3117             fi
3118             ;;
3119         *)
3120             wrapper=$file
3121             ;;
3122         esac
3123         if func_ltwrapper_script_p "$wrapper"; then
3124           notinst_deplibs=
3125           relink_command=
3126
3127           func_source "$wrapper"
3128
3129           # Check the variables that should have been set.
3130           test -z "$generated_by_libtool_version" && \
3131             func_fatal_error "invalid libtool wrapper script \`$wrapper'"
3132
3133           finalize=yes
3134           for lib in $notinst_deplibs; do
3135             # Check to see that each library is installed.
3136             libdir=
3137             if test -f "$lib"; then
3138               func_source "$lib"
3139             fi
3140             libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
3141             if test -n "$libdir" && test ! -f "$libfile"; then
3142               func_warning "\`$lib' has not been installed in \`$libdir'"
3143               finalize=no
3144             fi
3145           done
3146
3147           relink_command=
3148           func_source "$wrapper"
3149
3150           outputname=
3151           if test "$fast_install" = no && test -n "$relink_command"; then
3152             $opt_dry_run || {
3153               if test "$finalize" = yes; then
3154                 tmpdir=`func_mktempdir`
3155                 func_basename "$file$stripped_ext"
3156                 file="$func_basename_result"
3157                 outputname="$tmpdir/$file"
3158                 # Replace the output file specification.
3159                 relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
3160
3161                 $opt_silent || {
3162                   func_quote_for_expand "$relink_command"
3163                   eval "func_echo $func_quote_for_expand_result"
3164                 }
3165                 if eval "$relink_command"; then :
3166                   else
3167                   func_error "error: relink \`$file' with the above command before installing it"
3168                   $opt_dry_run || ${RM}r "$tmpdir"
3169                   continue
3170                 fi
3171                 file="$outputname"
3172               else
3173                 func_warning "cannot relink \`$file'"
3174               fi
3175             }
3176           else
3177             # Install the binary that we compiled earlier.
3178             file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
3179           fi
3180         fi
3181
3182         # remove .exe since cygwin /usr/bin/install will append another
3183         # one anyway
3184         case $install_prog,$host in
3185         */usr/bin/install*,*cygwin*)
3186           case $file:$destfile in
3187           *.exe:*.exe)
3188             # this is ok
3189             ;;
3190           *.exe:*)
3191             destfile=$destfile.exe
3192             ;;
3193           *:*.exe)
3194             func_stripname '' '.exe' "$destfile"
3195             destfile=$func_stripname_result
3196             ;;
3197           esac
3198           ;;
3199         esac
3200         func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
3201         $opt_dry_run || if test -n "$outputname"; then
3202           ${RM}r "$tmpdir"
3203         fi
3204         ;;
3205       esac
3206     done
3207
3208     for file in $staticlibs; do
3209       func_basename "$file"
3210       name="$func_basename_result"
3211
3212       # Set up the ranlib parameters.
3213       oldlib="$destdir/$name"
3214
3215       func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
3216
3217       if test -n "$stripme" && test -n "$old_striplib"; then
3218         func_show_eval "$old_striplib $oldlib" 'exit $?'
3219       fi
3220
3221       # Do each command in the postinstall commands.
3222       func_execute_cmds "$old_postinstall_cmds" 'exit $?'
3223     done
3224
3225     test -n "$future_libdirs" && \
3226       func_warning "remember to run \`$progname --finish$future_libdirs'"
3227
3228     if test -n "$current_libdirs"; then
3229       # Maybe just do a dry run.
3230       $opt_dry_run && current_libdirs=" -n$current_libdirs"
3231       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
3232     else
3233       exit $EXIT_SUCCESS
3234     fi
3235 }
3236
3237 test "$opt_mode" = install && func_mode_install ${1+"$@"}
3238
3239
3240 # func_generate_dlsyms outputname originator pic_p
3241 # Extract symbols from dlprefiles and create ${outputname}S.o with
3242 # a dlpreopen symbol table.
3243 func_generate_dlsyms ()
3244 {
3245     $opt_debug
3246     my_outputname="$1"
3247     my_originator="$2"
3248     my_pic_p="${3-no}"
3249     my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
3250     my_dlsyms=
3251
3252     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3253       if test -n "$NM" && test -n "$global_symbol_pipe"; then
3254         my_dlsyms="${my_outputname}S.c"
3255       else
3256         func_error "not configured to extract global symbols from dlpreopened files"
3257       fi
3258     fi
3259
3260     if test -n "$my_dlsyms"; then
3261       case $my_dlsyms in
3262       "") ;;
3263       *.c)
3264         # Discover the nlist of each of the dlfiles.
3265         nlist="$output_objdir/${my_outputname}.nm"
3266
3267         func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
3268
3269         # Parse the name list into a source file.
3270         func_verbose "creating $output_objdir/$my_dlsyms"
3271
3272         $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
3273 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
3274 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
3275
3276 #ifdef __cplusplus
3277 extern \"C\" {
3278 #endif
3279
3280 #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
3281 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
3282 #endif
3283
3284 /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
3285 #if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
3286 /* DATA imports from DLLs on WIN32 con't be const, because runtime
3287    relocations are performed -- see ld's documentation on pseudo-relocs.  */
3288 # define LT_DLSYM_CONST
3289 #elif defined(__osf__)
3290 /* This system does not cope well with relocations in const data.  */
3291 # define LT_DLSYM_CONST
3292 #else
3293 # define LT_DLSYM_CONST const
3294 #endif
3295
3296 /* External symbol declarations for the compiler. */\
3297 "
3298
3299         if test "$dlself" = yes; then
3300           func_verbose "generating symbol list for \`$output'"
3301
3302           $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
3303
3304           # Add our own program objects to the symbol list.
3305           progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
3306           for progfile in $progfiles; do
3307             func_to_tool_file "$progfile" func_convert_file_msys_to_w32
3308             func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
3309             $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
3310           done
3311
3312           if test -n "$exclude_expsyms"; then
3313             $opt_dry_run || {
3314               eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3315               eval '$MV "$nlist"T "$nlist"'
3316             }
3317           fi
3318
3319           if test -n "$export_symbols_regex"; then
3320             $opt_dry_run || {
3321               eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3322               eval '$MV "$nlist"T "$nlist"'
3323             }
3324           fi
3325
3326           # Prepare the list of exported symbols
3327           if test -z "$export_symbols"; then
3328             export_symbols="$output_objdir/$outputname.exp"
3329             $opt_dry_run || {
3330               $RM $export_symbols
3331               eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3332               case $host in
3333               *cygwin* | *mingw* | *cegcc* )
3334                 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3335                 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
3336                 ;;
3337               esac
3338             }
3339           else
3340             $opt_dry_run || {
3341               eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
3342               eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
3343               eval '$MV "$nlist"T "$nlist"'
3344               case $host in
3345                 *cygwin* | *mingw* | *cegcc* )
3346                   eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3347                   eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
3348                   ;;
3349               esac
3350             }
3351           fi
3352         fi
3353
3354         for dlprefile in $dlprefiles; do
3355           func_verbose "extracting global C symbols from \`$dlprefile'"
3356           func_basename "$dlprefile"
3357           name="$func_basename_result"
3358           case $host in
3359             *cygwin* | *mingw* | *cegcc* )
3360               # if an import library, we need to obtain dlname
3361               if func_win32_import_lib_p "$dlprefile"; then
3362                 func_tr_sh "$dlprefile"
3363                 eval "curr_lafile=\$libfile_$func_tr_sh_result"
3364                 dlprefile_dlbasename=""
3365                 if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
3366                   # Use subshell, to avoid clobbering current variable values
3367                   dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
3368                   if test -n "$dlprefile_dlname" ; then
3369                     func_basename "$dlprefile_dlname"
3370                     dlprefile_dlbasename="$func_basename_result"
3371                   else
3372                     # no lafile. user explicitly requested -dlpreopen <import library>.
3373                     $sharedlib_from_linklib_cmd "$dlprefile"
3374                     dlprefile_dlbasename=$sharedlib_from_linklib_result
3375                   fi
3376                 fi
3377                 $opt_dry_run || {
3378                   if test -n "$dlprefile_dlbasename" ; then
3379                     eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
3380                   else
3381                     func_warning "Could not compute DLL name from $name"
3382                     eval '$ECHO ": $name " >> "$nlist"'
3383                   fi
3384                   func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3385                   eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
3386                     $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
3387                 }
3388               else # not an import lib
3389                 $opt_dry_run || {
3390                   eval '$ECHO ": $name " >> "$nlist"'
3391                   func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3392                   eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3393                 }
3394               fi
3395             ;;
3396             *)
3397               $opt_dry_run || {
3398                 eval '$ECHO ": $name " >> "$nlist"'
3399                 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3400                 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3401               }
3402             ;;
3403           esac
3404         done
3405
3406         $opt_dry_run || {
3407           # Make sure we have at least an empty file.
3408           test -f "$nlist" || : > "$nlist"
3409
3410           if test -n "$exclude_expsyms"; then
3411             $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3412             $MV "$nlist"T "$nlist"
3413           fi
3414
3415           # Try sorting and uniquifying the output.
3416           if $GREP -v "^: " < "$nlist" |
3417               if sort -k 3 </dev/null >/dev/null 2>&1; then
3418                 sort -k 3
3419               else
3420                 sort +2
3421               fi |
3422               uniq > "$nlist"S; then
3423             :
3424           else
3425             $GREP -v "^: " < "$nlist" > "$nlist"S
3426           fi
3427
3428           if test -f "$nlist"S; then
3429             eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
3430           else
3431             echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
3432           fi
3433
3434           echo >> "$output_objdir/$my_dlsyms" "\
3435
3436 /* The mapping between symbol names and symbols.  */
3437 typedef struct {
3438   const char *name;
3439   void *address;
3440 } lt_dlsymlist;
3441 extern LT_DLSYM_CONST lt_dlsymlist
3442 lt_${my_prefix}_LTX_preloaded_symbols[];
3443 LT_DLSYM_CONST lt_dlsymlist
3444 lt_${my_prefix}_LTX_preloaded_symbols[] =
3445 {\
3446   { \"$my_originator\", (void *) 0 },"
3447
3448           case $need_lib_prefix in
3449           no)
3450             eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
3451             ;;
3452           *)
3453             eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
3454             ;;
3455           esac
3456           echo >> "$output_objdir/$my_dlsyms" "\
3457   {0, (void *) 0}
3458 };
3459
3460 /* This works around a problem in FreeBSD linker */
3461 #ifdef FREEBSD_WORKAROUND
3462 static const void *lt_preloaded_setup() {
3463   return lt_${my_prefix}_LTX_preloaded_symbols;
3464 }
3465 #endif
3466
3467 #ifdef __cplusplus
3468 }
3469 #endif\
3470 "
3471         } # !$opt_dry_run
3472
3473         pic_flag_for_symtable=
3474         case "$compile_command " in
3475         *" -static "*) ;;
3476         *)
3477           case $host in
3478           # compiling the symbol table file with pic_flag works around
3479           # a FreeBSD bug that causes programs to crash when -lm is
3480           # linked before any other PIC object.  But we must not use
3481           # pic_flag when linking with -static.  The problem exists in
3482           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3483           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3484             pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
3485           *-*-hpux*)
3486             pic_flag_for_symtable=" $pic_flag"  ;;
3487           *)
3488             if test "X$my_pic_p" != Xno; then
3489               pic_flag_for_symtable=" $pic_flag"
3490             fi
3491             ;;
3492           esac
3493           ;;
3494         esac
3495         symtab_cflags=
3496         for arg in $LTCFLAGS; do
3497           case $arg in
3498           -pie | -fpie | -fPIE) ;;
3499           *) func_append symtab_cflags " $arg" ;;
3500           esac
3501         done
3502
3503         # Now compile the dynamic symbol file.
3504         func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
3505
3506         # Clean up the generated files.
3507         func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3508
3509         # Transform the symbol file into the correct name.
3510         symfileobj="$output_objdir/${my_outputname}S.$objext"
3511         case $host in
3512         *cygwin* | *mingw* | *cegcc* )
3513           if test -f "$output_objdir/$my_outputname.def"; then
3514             compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3515             finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3516           else
3517             compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3518             finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3519           fi
3520           ;;
3521         *)
3522           compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3523           finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3524           ;;
3525         esac
3526         ;;
3527       *)
3528         func_fatal_error "unknown suffix for \`$my_dlsyms'"
3529         ;;
3530       esac
3531     else
3532       # We keep going just in case the user didn't refer to
3533       # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
3534       # really was required.
3535
3536       # Nullify the symbol file.
3537       compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3538       finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
3539     fi
3540 }
3541
3542 # func_win32_libid arg
3543 # return the library type of file 'arg'
3544 #
3545 # Need a lot of goo to handle *both* DLLs and import libs
3546 # Has to be a shell function in order to 'eat' the argument
3547 # that is supplied when $file_magic_command is called.
3548 # Despite the name, also deal with 64 bit binaries.
3549 func_win32_libid ()
3550 {
3551   $opt_debug
3552   win32_libid_type="unknown"
3553   win32_fileres=`file -L $1 2>/dev/null`
3554   case $win32_fileres in
3555   *ar\ archive\ import\ library*) # definitely import
3556     win32_libid_type="x86 archive import"
3557     ;;
3558   *ar\ archive*) # could be an import, or static
3559     # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
3560     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
3561        $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
3562       func_to_tool_file "$1" func_convert_file_msys_to_w32
3563       win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
3564         $SED -n -e '
3565             1,100{
3566                 / I /{
3567                     s,.*,import,
3568                     p
3569                     q
3570                 }
3571             }'`
3572       case $win32_nmres in
3573       import*)  win32_libid_type="x86 archive import";;
3574       *)        win32_libid_type="x86 archive static";;
3575       esac
3576     fi
3577     ;;
3578   *DLL*)
3579     win32_libid_type="x86 DLL"
3580     ;;
3581   *executable*) # but shell scripts are "executable" too...
3582     case $win32_fileres in
3583     *MS\ Windows\ PE\ Intel*)
3584       win32_libid_type="x86 DLL"
3585       ;;
3586     esac
3587     ;;
3588   esac
3589   $ECHO "$win32_libid_type"
3590 }
3591
3592 # func_cygming_dll_for_implib ARG
3593 #
3594 # Platform-specific function to extract the
3595 # name of the DLL associated with the specified
3596 # import library ARG.
3597 # Invoked by eval'ing the libtool variable
3598 #    $sharedlib_from_linklib_cmd
3599 # Result is available in the variable
3600 #    $sharedlib_from_linklib_result
3601 func_cygming_dll_for_implib ()
3602 {
3603   $opt_debug
3604   sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
3605 }
3606
3607 # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
3608 #
3609 # The is the core of a fallback implementation of a
3610 # platform-specific function to extract the name of the
3611 # DLL associated with the specified import library LIBNAME.
3612 #
3613 # SECTION_NAME is either .idata$6 or .idata$7, depending
3614 # on the platform and compiler that created the implib.
3615 #
3616 # Echos the name of the DLL associated with the
3617 # specified import library.
3618 func_cygming_dll_for_implib_fallback_core ()
3619 {
3620   $opt_debug
3621   match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
3622   $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
3623     $SED '/^Contents of section '"$match_literal"':/{
3624       # Place marker at beginning of archive member dllname section
3625       s/.*/====MARK====/
3626       p
3627       d
3628     }
3629     # These lines can sometimes be longer than 43 characters, but
3630     # are always uninteresting
3631     /:[  ]*file format pe[i]\{,1\}-/d
3632     /^In archive [^:]*:/d
3633     # Ensure marker is printed
3634     /^====MARK====/p
3635     # Remove all lines with less than 43 characters
3636     /^.\{43\}/!d
3637     # From remaining lines, remove first 43 characters
3638     s/^.\{43\}//' |
3639     $SED -n '
3640       # Join marker and all lines until next marker into a single line
3641       /^====MARK====/ b para
3642       H
3643       $ b para
3644       b
3645       :para
3646       x
3647       s/\n//g
3648       # Remove the marker
3649       s/^====MARK====//
3650       # Remove trailing dots and whitespace
3651       s/[\. \t]*$//
3652       # Print
3653       /./p' |
3654     # we now have a list, one entry per line, of the stringified
3655     # contents of the appropriate section of all members of the
3656     # archive which possess that section. Heuristic: eliminate
3657     # all those which have a first or second character that is
3658     # a '.' (that is, objdump's representation of an unprintable
3659     # character.) This should work for all archives with less than
3660     # 0x302f exports -- but will fail for DLLs whose name actually
3661     # begins with a literal '.' or a single character followed by
3662     # a '.'.
3663     #
3664     # Of those that remain, print the first one.
3665     $SED -e '/^\./d;/^.\./d;q'
3666 }
3667
3668 # func_cygming_gnu_implib_p ARG
3669 # This predicate returns with zero status (TRUE) if
3670 # ARG is a GNU/binutils-style import library. Returns
3671 # with nonzero status (FALSE) otherwise.
3672 func_cygming_gnu_implib_p ()
3673 {
3674   $opt_debug
3675   func_to_tool_file "$1" func_convert_file_msys_to_w32
3676   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)$'`
3677   test -n "$func_cygming_gnu_implib_tmp"
3678 }
3679
3680 # func_cygming_ms_implib_p ARG
3681 # This predicate returns with zero status (TRUE) if
3682 # ARG is an MS-style import library. Returns
3683 # with nonzero status (FALSE) otherwise.
3684 func_cygming_ms_implib_p ()
3685 {
3686   $opt_debug
3687   func_to_tool_file "$1" func_convert_file_msys_to_w32
3688   func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
3689   test -n "$func_cygming_ms_implib_tmp"
3690 }
3691
3692 # func_cygming_dll_for_implib_fallback ARG
3693 # Platform-specific function to extract the
3694 # name of the DLL associated with the specified
3695 # import library ARG.
3696 #
3697 # This fallback implementation is for use when $DLLTOOL
3698 # does not support the --identify-strict option.
3699 # Invoked by eval'ing the libtool variable
3700 #    $sharedlib_from_linklib_cmd
3701 # Result is available in the variable
3702 #    $sharedlib_from_linklib_result
3703 func_cygming_dll_for_implib_fallback ()
3704 {
3705   $opt_debug
3706   if func_cygming_gnu_implib_p "$1" ; then
3707     # binutils import library
3708     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
3709   elif func_cygming_ms_implib_p "$1" ; then
3710     # ms-generated import library
3711     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
3712   else
3713     # unknown
3714     sharedlib_from_linklib_result=""
3715   fi
3716 }
3717
3718
3719 # func_extract_an_archive dir oldlib
3720 func_extract_an_archive ()
3721 {
3722     $opt_debug
3723     f_ex_an_ar_dir="$1"; shift
3724     f_ex_an_ar_oldlib="$1"
3725     if test "$lock_old_archive_extraction" = yes; then
3726       lockfile=$f_ex_an_ar_oldlib.lock
3727       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
3728         func_echo "Waiting for $lockfile to be removed"
3729         sleep 2
3730       done
3731     fi
3732     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
3733                    'stat=$?; rm -f "$lockfile"; exit $stat'
3734     if test "$lock_old_archive_extraction" = yes; then
3735       $opt_dry_run || rm -f "$lockfile"
3736     fi
3737     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
3738      :
3739     else
3740       func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3741     fi
3742 }
3743
3744
3745 # func_extract_archives gentop oldlib ...
3746 func_extract_archives ()
3747 {
3748     $opt_debug
3749     my_gentop="$1"; shift
3750     my_oldlibs=${1+"$@"}
3751     my_oldobjs=""
3752     my_xlib=""
3753     my_xabs=""
3754     my_xdir=""
3755
3756     for my_xlib in $my_oldlibs; do
3757       # Extract the objects.
3758       case $my_xlib in
3759         [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
3760         *) my_xabs=`pwd`"/$my_xlib" ;;
3761       esac
3762       func_basename "$my_xlib"
3763       my_xlib="$func_basename_result"
3764       my_xlib_u=$my_xlib
3765       while :; do
3766         case " $extracted_archives " in
3767         *" $my_xlib_u "*)
3768           func_arith $extracted_serial + 1
3769           extracted_serial=$func_arith_result
3770           my_xlib_u=lt$extracted_serial-$my_xlib ;;
3771         *) break ;;
3772         esac
3773       done
3774       extracted_archives="$extracted_archives $my_xlib_u"
3775       my_xdir="$my_gentop/$my_xlib_u"
3776
3777       func_mkdir_p "$my_xdir"
3778
3779       case $host in
3780       *-darwin*)
3781         func_verbose "Extracting $my_xabs"
3782         # Do not bother doing anything if just a dry run
3783         $opt_dry_run || {
3784           darwin_orig_dir=`pwd`
3785           cd $my_xdir || exit $?
3786           darwin_archive=$my_xabs
3787           darwin_curdir=`pwd`
3788           darwin_base_archive=`basename "$darwin_archive"`
3789           darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3790           if test -n "$darwin_arches"; then
3791             darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3792             darwin_arch=
3793             func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
3794             for darwin_arch in  $darwin_arches ; do
3795               func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3796               $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3797               cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3798               func_extract_an_archive "`pwd`" "${darwin_base_archive}"
3799               cd "$darwin_curdir"
3800               $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3801             done # $darwin_arches
3802             ## Okay now we've a bunch of thin objects, gotta fatten them up :)
3803             darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3804             darwin_file=
3805             darwin_files=
3806             for darwin_file in $darwin_filelist; do
3807               darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
3808               $LIPO -create -output "$darwin_file" $darwin_files
3809             done # $darwin_filelist
3810             $RM -rf unfat-$$
3811             cd "$darwin_orig_dir"
3812           else
3813             cd $darwin_orig_dir
3814             func_extract_an_archive "$my_xdir" "$my_xabs"
3815           fi # $darwin_arches
3816         } # !$opt_dry_run
3817         ;;
3818       *)
3819         func_extract_an_archive "$my_xdir" "$my_xabs"
3820         ;;
3821       esac
3822       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
3823     done
3824
3825     func_extract_archives_result="$my_oldobjs"
3826 }
3827
3828
3829 # func_emit_wrapper [arg=no]
3830 #
3831 # Emit a libtool wrapper script on stdout.
3832 # Don't directly open a file because we may want to
3833 # incorporate the script contents within a cygwin/mingw
3834 # wrapper executable.  Must ONLY be called from within
3835 # func_mode_link because it depends on a number of variables
3836 # set therein.
3837 #
3838 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3839 # variable will take.  If 'yes', then the emitted script
3840 # will assume that the directory in which it is stored is
3841 # the $objdir directory.  This is a cygwin/mingw-specific
3842 # behavior.
3843 func_emit_wrapper ()
3844 {
3845         func_emit_wrapper_arg1=${1-no}
3846
3847         $ECHO "\
3848 #! $SHELL
3849
3850 # $output - temporary wrapper script for $objdir/$outputname
3851 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3852 #
3853 # The $output program cannot be directly executed until all the libtool
3854 # libraries that it depends on are installed.
3855 #
3856 # This wrapper script should never be moved out of the build directory.
3857 # If it is, it will not operate correctly.
3858
3859 # Sed substitution that helps us do robust quoting.  It backslashifies
3860 # metacharacters that are still active within double-quoted strings.
3861 sed_quote_subst='$sed_quote_subst'
3862
3863 # Be Bourne compatible
3864 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
3865   emulate sh
3866   NULLCMD=:
3867   # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
3868   # is contrary to our usage.  Disable this feature.
3869   alias -g '\${1+\"\$@\"}'='\"\$@\"'
3870   setopt NO_GLOB_SUBST
3871 else
3872   case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
3873 fi
3874 BIN_SH=xpg4; export BIN_SH # for Tru64
3875 DUALCASE=1; export DUALCASE # for MKS sh
3876
3877 # The HP-UX ksh and POSIX shell print the target directory to stdout
3878 # if CDPATH is set.
3879 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
3880
3881 relink_command=\"$relink_command\"
3882
3883 # This environment variable determines our operation mode.
3884 if test \"\$libtool_install_magic\" = \"$magic\"; then
3885   # install mode needs the following variables:
3886   generated_by_libtool_version='$macro_version'
3887   notinst_deplibs='$notinst_deplibs'
3888 else
3889   # When we are sourced in execute mode, \$file and \$ECHO are already set.
3890   if test \"\$libtool_execute_magic\" != \"$magic\"; then
3891     file=\"\$0\""
3892
3893     qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3894     $ECHO "\
3895
3896 # A function that is used when there is no print builtin or printf.
3897 func_fallback_echo ()
3898 {
3899   eval 'cat <<_LTECHO_EOF
3900 \$1
3901 _LTECHO_EOF'
3902 }
3903     ECHO=\"$qECHO\"
3904   fi
3905
3906 # Very basic option parsing. These options are (a) specific to
3907 # the libtool wrapper, (b) are identical between the wrapper
3908 # /script/ and the wrapper /executable/ which is used only on
3909 # windows platforms, and (c) all begin with the string "--lt-"
3910 # (application programs are unlikely to have options which match
3911 # this pattern).
3912 #
3913 # There are only two supported options: --lt-debug and
3914 # --lt-dump-script. There is, deliberately, no --lt-help.
3915 #
3916 # The first argument to this parsing function should be the
3917 # script's $0 value, followed by "$@".
3918 lt_option_debug=
3919 func_parse_lt_options ()
3920 {
3921   lt_script_arg0=\$0
3922   shift
3923   for lt_opt
3924   do
3925     case \"\$lt_opt\" in
3926     --lt-debug) lt_option_debug=1 ;;
3927     --lt-dump-script)
3928         lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
3929         test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
3930         lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
3931         cat \"\$lt_dump_D/\$lt_dump_F\"
3932         exit 0
3933       ;;
3934     --lt-*)
3935         \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
3936         exit 1
3937       ;;
3938     esac
3939   done
3940
3941   # Print the debug banner immediately:
3942   if test -n \"\$lt_option_debug\"; then
3943     echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
3944   fi
3945 }
3946
3947 # Used when --lt-debug. Prints its arguments to stdout
3948 # (redirection is the responsibility of the caller)
3949 func_lt_dump_args ()
3950 {
3951   lt_dump_args_N=1;
3952   for lt_arg
3953   do
3954     \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
3955     lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
3956   done
3957 }
3958
3959 # Core function for launching the target application
3960 func_exec_program_core ()
3961 {
3962 "
3963   case $host in
3964   # Backslashes separate directories on plain windows
3965   *-*-mingw | *-*-os2* | *-cegcc*)
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
3975   *)
3976     $ECHO "\
3977       if test -n \"\$lt_option_debug\"; then
3978         \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
3979         func_lt_dump_args \${1+\"\$@\"} 1>&2
3980       fi
3981       exec \"\$progdir/\$program\" \${1+\"\$@\"}
3982 "
3983     ;;
3984   esac
3985   $ECHO "\
3986       \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3987       exit 1
3988 }
3989
3990 # A function to encapsulate launching the target application
3991 # Strips options in the --lt-* namespace from \$@ and
3992 # launches target application with the remaining arguments.
3993 func_exec_program ()
3994 {
3995   for lt_wr_arg
3996   do
3997     case \$lt_wr_arg in
3998     --lt-*) ;;
3999     *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
4000     esac
4001     shift
4002   done
4003   func_exec_program_core \${1+\"\$@\"}
4004 }
4005
4006   # Parse options
4007   func_parse_lt_options \"\$0\" \${1+\"\$@\"}
4008
4009   # Find the directory that this script lives in.
4010   thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
4011   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4012
4013   # Follow symbolic links until we get to the real thisdir.
4014   file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
4015   while test -n \"\$file\"; do
4016     destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
4017
4018     # If there was a directory component, then change thisdir.
4019     if test \"x\$destdir\" != \"x\$file\"; then
4020       case \"\$destdir\" in
4021       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4022       *) thisdir=\"\$thisdir/\$destdir\" ;;
4023       esac
4024     fi
4025
4026     file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
4027     file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
4028   done
4029
4030   # Usually 'no', except on cygwin/mingw when embedded into
4031   # the cwrapper.
4032   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
4033   if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
4034     # special case for '.'
4035     if test \"\$thisdir\" = \".\"; then
4036       thisdir=\`pwd\`
4037     fi
4038     # remove .libs from thisdir
4039     case \"\$thisdir\" in
4040     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
4041     $objdir )   thisdir=. ;;
4042     esac
4043   fi
4044
4045   # Try to get the absolute directory name.
4046   absdir=\`cd \"\$thisdir\" && pwd\`
4047   test -n \"\$absdir\" && thisdir=\"\$absdir\"
4048 "
4049
4050         if test "$fast_install" = yes; then
4051           $ECHO "\
4052   program=lt-'$outputname'$exeext
4053   progdir=\"\$thisdir/$objdir\"
4054
4055   if test ! -f \"\$progdir/\$program\" ||
4056      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4057        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4058
4059     file=\"\$\$-\$program\"
4060
4061     if test ! -d \"\$progdir\"; then
4062       $MKDIR \"\$progdir\"
4063     else
4064       $RM \"\$progdir/\$file\"
4065     fi"
4066
4067           $ECHO "\
4068
4069     # relink executable if necessary
4070     if test -n \"\$relink_command\"; then
4071       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4072       else
4073         $ECHO \"\$relink_command_output\" >&2
4074         $RM \"\$progdir/\$file\"
4075         exit 1
4076       fi
4077     fi
4078
4079     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4080     { $RM \"\$progdir/\$program\";
4081       $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4082     $RM \"\$progdir/\$file\"
4083   fi"
4084         else
4085           $ECHO "\
4086   program='$outputname'
4087   progdir=\"\$thisdir/$objdir\"
4088 "
4089         fi
4090
4091         $ECHO "\
4092
4093   if test -f \"\$progdir/\$program\"; then"
4094
4095         # fixup the dll searchpath if we need to.
4096         #
4097         # Fix the DLL searchpath if we need to.  Do this before prepending
4098         # to shlibpath, because on Windows, both are PATH and uninstalled
4099         # libraries must come first.
4100         if test -n "$dllsearchpath"; then
4101           $ECHO "\
4102     # Add the dll search path components to the executable PATH
4103     PATH=$dllsearchpath:\$PATH
4104 "
4105         fi
4106
4107         # Export our shlibpath_var if we have one.
4108         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4109           $ECHO "\
4110     # Add our own library path to $shlibpath_var
4111     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4112
4113     # Some systems cannot cope with colon-terminated $shlibpath_var
4114     # The second colon is a workaround for a bug in BeOS R4 sed
4115     $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
4116
4117     export $shlibpath_var
4118 "
4119         fi
4120
4121         $ECHO "\
4122     if test \"\$libtool_execute_magic\" != \"$magic\"; then
4123       # Run the actual program with our arguments.
4124       func_exec_program \${1+\"\$@\"}
4125     fi
4126   else
4127     # The program doesn't exist.
4128     \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
4129     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
4130     \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
4131     exit 1
4132   fi
4133 fi\
4134 "
4135 }
4136
4137
4138 # func_emit_cwrapperexe_src
4139 # emit the source code for a wrapper executable on stdout
4140 # Must ONLY be called from within func_mode_link because
4141 # it depends on a number of variable set therein.
4142 func_emit_cwrapperexe_src ()
4143 {
4144         cat <<EOF
4145
4146 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4147    Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
4148
4149    The $output program cannot be directly executed until all the libtool
4150    libraries that it depends on are installed.
4151
4152    This wrapper executable should never be moved out of the build directory.
4153    If it is, it will not operate correctly.
4154 */
4155 EOF
4156             cat <<"EOF"
4157 #ifdef _MSC_VER
4158 # define _CRT_SECURE_NO_DEPRECATE 1
4159 #endif
4160 #include <stdio.h>
4161 #include <stdlib.h>
4162 #ifdef _MSC_VER
4163 # include <direct.h>
4164 # include <process.h>
4165 # include <io.h>
4166 #else
4167 # include <unistd.h>
4168 # include <stdint.h>
4169 # ifdef __CYGWIN__
4170 #  include <io.h>
4171 # endif
4172 #endif
4173 #include <malloc.h>
4174 #include <stdarg.h>
4175 #include <assert.h>
4176 #include <string.h>
4177 #include <ctype.h>
4178 #include <errno.h>
4179 #include <fcntl.h>
4180 #include <sys/stat.h>
4181
4182 /* declarations of non-ANSI functions */
4183 #if defined(__MINGW32__)
4184 # ifdef __STRICT_ANSI__
4185 int _putenv (const char *);
4186 # endif
4187 #elif defined(__CYGWIN__)
4188 # ifdef __STRICT_ANSI__
4189 char *realpath (const char *, char *);
4190 int putenv (char *);
4191 int setenv (const char *, const char *, int);
4192 # endif
4193 /* #elif defined (other platforms) ... */
4194 #endif
4195
4196 /* portability defines, excluding path handling macros */
4197 #if defined(_MSC_VER)
4198 # define setmode _setmode
4199 # define stat    _stat
4200 # define chmod   _chmod
4201 # define getcwd  _getcwd
4202 # define putenv  _putenv
4203 # define S_IXUSR _S_IEXEC
4204 # ifndef _INTPTR_T_DEFINED
4205 #  define _INTPTR_T_DEFINED
4206 #  define intptr_t int
4207 # endif
4208 #elif defined(__MINGW32__)
4209 # define setmode _setmode
4210 # define stat    _stat
4211 # define chmod   _chmod
4212 # define getcwd  _getcwd
4213 # define putenv  _putenv
4214 #elif defined(__CYGWIN__)
4215 # define HAVE_SETENV
4216 # define FOPEN_WB "wb"
4217 /* #elif defined (other platforms) ... */
4218 #endif
4219
4220 #if defined(PATH_MAX)
4221 # define LT_PATHMAX PATH_MAX
4222 #elif defined(MAXPATHLEN)
4223 # define LT_PATHMAX MAXPATHLEN
4224 #else
4225 # define LT_PATHMAX 1024
4226 #endif
4227
4228 #ifndef S_IXOTH
4229 # define S_IXOTH 0
4230 #endif
4231 #ifndef S_IXGRP
4232 # define S_IXGRP 0
4233 #endif
4234
4235 /* path handling portability macros */
4236 #ifndef DIR_SEPARATOR
4237 # define DIR_SEPARATOR '/'
4238 # define PATH_SEPARATOR ':'
4239 #endif
4240
4241 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4242   defined (__OS2__)
4243 # define HAVE_DOS_BASED_FILE_SYSTEM
4244 # define FOPEN_WB "wb"
4245 # ifndef DIR_SEPARATOR_2
4246 #  define DIR_SEPARATOR_2 '\\'
4247 # endif
4248 # ifndef PATH_SEPARATOR_2
4249 #  define PATH_SEPARATOR_2 ';'
4250 # endif
4251 #endif
4252
4253 #ifndef DIR_SEPARATOR_2
4254 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4255 #else /* DIR_SEPARATOR_2 */
4256 # define IS_DIR_SEPARATOR(ch) \
4257         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4258 #endif /* DIR_SEPARATOR_2 */
4259
4260 #ifndef PATH_SEPARATOR_2
4261 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
4262 #else /* PATH_SEPARATOR_2 */
4263 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
4264 #endif /* PATH_SEPARATOR_2 */
4265
4266 #ifndef FOPEN_WB
4267 # define FOPEN_WB "w"
4268 #endif
4269 #ifndef _O_BINARY
4270 # define _O_BINARY 0
4271 #endif
4272
4273 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
4274 #define XFREE(stale) do { \
4275   if (stale) { free ((void *) stale); stale = 0; } \
4276 } while (0)
4277
4278 #if defined(LT_DEBUGWRAPPER)
4279 static int lt_debug = 1;
4280 #else
4281 static int lt_debug = 0;
4282 #endif
4283
4284 const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
4285
4286 void *xmalloc (size_t num);
4287 char *xstrdup (const char *string);
4288 const char *base_name (const char *name);
4289 char *find_executable (const char *wrapper);
4290 char *chase_symlinks (const char *pathspec);
4291 int make_executable (const char *path);
4292 int check_executable (const char *path);
4293 char *strendzap (char *str, const char *pat);
4294 void lt_debugprintf (const char *file, int line, const char *fmt, ...);
4295 void lt_fatal (const char *file, int line, const char *message, ...);
4296 static const char *nonnull (const char *s);
4297 static const char *nonempty (const char *s);
4298 void lt_setenv (const char *name, const char *value);
4299 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
4300 void lt_update_exe_path (const char *name, const char *value);
4301 void lt_update_lib_path (const char *name, const char *value);
4302 char **prepare_spawn (char **argv);
4303 void lt_dump_script (FILE *f);
4304 EOF
4305
4306             cat <<EOF
4307 volatile const char * MAGIC_EXE = "$magic_exe";
4308 const char * LIB_PATH_VARNAME = "$shlibpath_var";
4309 EOF
4310
4311             if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4312               func_to_host_path "$temp_rpath"
4313               cat <<EOF
4314 const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
4315 EOF
4316             else
4317               cat <<"EOF"
4318 const char * LIB_PATH_VALUE   = "";
4319 EOF
4320             fi
4321
4322             if test -n "$dllsearchpath"; then
4323               func_to_host_path "$dllsearchpath:"
4324               cat <<EOF
4325 const char * EXE_PATH_VARNAME = "PATH";
4326 const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
4327 EOF
4328             else
4329               cat <<"EOF"
4330 const char * EXE_PATH_VARNAME = "";
4331 const char * EXE_PATH_VALUE   = "";
4332 EOF
4333             fi
4334
4335             if test "$fast_install" = yes; then
4336               cat <<EOF
4337 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
4338 EOF
4339             else
4340               cat <<EOF
4341 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
4342 EOF
4343             fi
4344
4345
4346             cat <<"EOF"
4347
4348 #define LTWRAPPER_OPTION_PREFIX         "--lt-"
4349
4350 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
4351 static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
4352 static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
4353
4354 int
4355 main (int argc, char *argv[])
4356 {
4357   char **newargz;
4358   int  newargc;
4359   char *tmp_pathspec;
4360   char *actual_cwrapper_path;
4361   char *actual_cwrapper_name;
4362   char *target_name;
4363   char *lt_argv_zero;
4364   intptr_t rval = 127;
4365
4366   int i;
4367
4368   program_name = (char *) xstrdup (base_name (argv[0]));
4369   newargz = XMALLOC (char *, argc + 1);
4370
4371   /* very simple arg parsing; don't want to rely on getopt
4372    * also, copy all non cwrapper options to newargz, except
4373    * argz[0], which is handled differently
4374    */
4375   newargc=0;
4376   for (i = 1; i < argc; i++)
4377     {
4378       if (strcmp (argv[i], dumpscript_opt) == 0)
4379         {
4380 EOF
4381             case "$host" in
4382               *mingw* | *cygwin* )
4383                 # make stdout use "unix" line endings
4384                 echo "          setmode(1,_O_BINARY);"
4385                 ;;
4386               esac
4387
4388             cat <<"EOF"
4389           lt_dump_script (stdout);
4390           return 0;
4391         }
4392       if (strcmp (argv[i], debug_opt) == 0)
4393         {
4394           lt_debug = 1;
4395           continue;
4396         }
4397       if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
4398         {
4399           /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
4400              namespace, but it is not one of the ones we know about and
4401              have already dealt with, above (inluding dump-script), then
4402              report an error. Otherwise, targets might begin to believe
4403              they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
4404              namespace. The first time any user complains about this, we'll
4405              need to make LTWRAPPER_OPTION_PREFIX a configure-time option
4406              or a configure.ac-settable value.
4407            */
4408           lt_fatal (__FILE__, __LINE__,
4409                     "unrecognized %s option: '%s'",
4410                     ltwrapper_option_prefix, argv[i]);
4411         }
4412       /* otherwise ... */
4413       newargz[++newargc] = xstrdup (argv[i]);
4414     }
4415   newargz[++newargc] = NULL;
4416
4417 EOF
4418             cat <<EOF
4419   /* The GNU banner must be the first non-error debug message */
4420   lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
4421 EOF
4422             cat <<"EOF"
4423   lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
4424   lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
4425
4426   tmp_pathspec = find_executable (argv[0]);
4427   if (tmp_pathspec == NULL)
4428     lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
4429   lt_debugprintf (__FILE__, __LINE__,
4430                   "(main) found exe (before symlink chase) at: %s\n",
4431                   tmp_pathspec);
4432
4433   actual_cwrapper_path = chase_symlinks (tmp_pathspec);
4434   lt_debugprintf (__FILE__, __LINE__,
4435                   "(main) found exe (after symlink chase) at: %s\n",
4436                   actual_cwrapper_path);
4437   XFREE (tmp_pathspec);
4438
4439   actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
4440   strendzap (actual_cwrapper_path, actual_cwrapper_name);
4441
4442   /* wrapper name transforms */
4443   strendzap (actual_cwrapper_name, ".exe");
4444   tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
4445   XFREE (actual_cwrapper_name);
4446   actual_cwrapper_name = tmp_pathspec;
4447   tmp_pathspec = 0;
4448
4449   /* target_name transforms -- use actual target program name; might have lt- prefix */
4450   target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
4451   strendzap (target_name, ".exe");
4452   tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
4453   XFREE (target_name);
4454   target_name = tmp_pathspec;
4455   tmp_pathspec = 0;
4456
4457   lt_debugprintf (__FILE__, __LINE__,
4458                   "(main) libtool target name: %s\n",
4459                   target_name);
4460 EOF
4461
4462             cat <<EOF
4463   newargz[0] =
4464     XMALLOC (char, (strlen (actual_cwrapper_path) +
4465                     strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
4466   strcpy (newargz[0], actual_cwrapper_path);
4467   strcat (newargz[0], "$objdir");
4468   strcat (newargz[0], "/");
4469 EOF
4470
4471             cat <<"EOF"
4472   /* stop here, and copy so we don't have to do this twice */
4473   tmp_pathspec = xstrdup (newargz[0]);
4474
4475   /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
4476   strcat (newargz[0], actual_cwrapper_name);
4477
4478   /* DO want the lt- prefix here if it exists, so use target_name */
4479   lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
4480   XFREE (tmp_pathspec);
4481   tmp_pathspec = NULL;
4482 EOF
4483
4484             case $host_os in
4485               mingw*)
4486             cat <<"EOF"
4487   {
4488     char* p;
4489     while ((p = strchr (newargz[0], '\\')) != NULL)
4490       {
4491         *p = '/';
4492       }
4493     while ((p = strchr (lt_argv_zero, '\\')) != NULL)
4494       {
4495         *p = '/';
4496       }
4497   }
4498 EOF
4499             ;;
4500             esac
4501
4502             cat <<"EOF"
4503   XFREE (target_name);
4504   XFREE (actual_cwrapper_path);
4505   XFREE (actual_cwrapper_name);
4506
4507   lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
4508   lt_setenv ("DUALCASE", "1");  /* for MSK sh */
4509   /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
4510      be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
4511      because on Windows, both *_VARNAMEs are PATH but uninstalled
4512      libraries must come first. */
4513   lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
4514   lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
4515
4516   lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
4517                   nonnull (lt_argv_zero));
4518   for (i = 0; i < newargc; i++)
4519     {
4520       lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
4521                       i, nonnull (newargz[i]));
4522     }
4523
4524 EOF
4525
4526             case $host_os in
4527               mingw*)
4528                 cat <<"EOF"
4529   /* execv doesn't actually work on mingw as expected on unix */
4530   newargz = prepare_spawn (newargz);
4531   rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
4532   if (rval == -1)
4533     {
4534       /* failed to start process */
4535       lt_debugprintf (__FILE__, __LINE__,
4536                       "(main) failed to launch target \"%s\": %s\n",
4537                       lt_argv_zero, nonnull (strerror (errno)));
4538       return 127;
4539     }
4540   return rval;
4541 EOF
4542                 ;;
4543               *)
4544                 cat <<"EOF"
4545   execv (lt_argv_zero, newargz);
4546   return rval; /* =127, but avoids unused variable warning */
4547 EOF
4548                 ;;
4549             esac
4550
4551             cat <<"EOF"
4552 }
4553
4554 void *
4555 xmalloc (size_t num)
4556 {
4557   void *p = (void *) malloc (num);
4558   if (!p)
4559     lt_fatal (__FILE__, __LINE__, "memory exhausted");
4560
4561   return p;
4562 }
4563
4564 char *
4565 xstrdup (const char *string)
4566 {
4567   return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
4568                           string) : NULL;
4569 }
4570
4571 const char *
4572 base_name (const char *name)
4573 {
4574   const char *base;
4575
4576 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4577   /* Skip over the disk name in MSDOS pathnames. */
4578   if (isalpha ((unsigned char) name[0]) && name[1] == ':')
4579     name += 2;
4580 #endif
4581
4582   for (base = name; *name; name++)
4583     if (IS_DIR_SEPARATOR (*name))
4584       base = name + 1;
4585   return base;
4586 }
4587
4588 int
4589 check_executable (const char *path)
4590 {
4591   struct stat st;
4592
4593   lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
4594                   nonempty (path));
4595   if ((!path) || (!*path))
4596     return 0;
4597
4598   if ((stat (path, &st) >= 0)
4599       && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
4600     return 1;
4601   else
4602     return 0;
4603 }
4604
4605 int
4606 make_executable (const char *path)
4607 {
4608   int rval = 0;
4609   struct stat st;
4610
4611   lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
4612                   nonempty (path));
4613   if ((!path) || (!*path))
4614     return 0;
4615
4616   if (stat (path, &st) >= 0)
4617     {
4618       rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
4619     }
4620   return rval;
4621 }
4622
4623 /* Searches for the full path of the wrapper.  Returns
4624    newly allocated full path name if found, NULL otherwise
4625    Does not chase symlinks, even on platforms that support them.
4626 */
4627 char *
4628 find_executable (const char *wrapper)
4629 {
4630   int has_slash = 0;
4631   const char *p;
4632   const char *p_next;
4633   /* static buffer for getcwd */
4634   char tmp[LT_PATHMAX + 1];
4635   int tmp_len;
4636   char *concat_name;
4637
4638   lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
4639                   nonempty (wrapper));
4640
4641   if ((wrapper == NULL) || (*wrapper == '\0'))
4642     return NULL;
4643
4644   /* Absolute path? */
4645 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4646   if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
4647     {
4648       concat_name = xstrdup (wrapper);
4649       if (check_executable (concat_name))
4650         return concat_name;
4651       XFREE (concat_name);
4652     }
4653   else
4654     {
4655 #endif
4656       if (IS_DIR_SEPARATOR (wrapper[0]))
4657         {
4658           concat_name = xstrdup (wrapper);
4659           if (check_executable (concat_name))
4660             return concat_name;
4661           XFREE (concat_name);
4662         }
4663 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4664     }
4665 #endif
4666
4667   for (p = wrapper; *p; p++)
4668     if (*p == '/')
4669       {
4670         has_slash = 1;
4671         break;
4672       }
4673   if (!has_slash)
4674     {
4675       /* no slashes; search PATH */
4676       const char *path = getenv ("PATH");
4677       if (path != NULL)
4678         {
4679           for (p = path; *p; p = p_next)
4680             {
4681               const char *q;
4682               size_t p_len;
4683               for (q = p; *q; q++)
4684                 if (IS_PATH_SEPARATOR (*q))
4685                   break;
4686               p_len = q - p;
4687               p_next = (*q == '\0' ? q : q + 1);
4688               if (p_len == 0)
4689                 {
4690                   /* empty path: current directory */
4691                   if (getcwd (tmp, LT_PATHMAX) == NULL)
4692                     lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4693                               nonnull (strerror (errno)));
4694                   tmp_len = strlen (tmp);
4695                   concat_name =
4696                     XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4697                   memcpy (concat_name, tmp, tmp_len);
4698                   concat_name[tmp_len] = '/';
4699                   strcpy (concat_name + tmp_len + 1, wrapper);
4700                 }
4701               else
4702                 {
4703                   concat_name =
4704                     XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
4705                   memcpy (concat_name, p, p_len);
4706                   concat_name[p_len] = '/';
4707                   strcpy (concat_name + p_len + 1, wrapper);
4708                 }
4709               if (check_executable (concat_name))
4710                 return concat_name;
4711               XFREE (concat_name);
4712             }
4713         }
4714       /* not found in PATH; assume curdir */
4715     }
4716   /* Relative path | not found in path: prepend cwd */
4717   if (getcwd (tmp, LT_PATHMAX) == NULL)
4718     lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4719               nonnull (strerror (errno)));
4720   tmp_len = strlen (tmp);
4721   concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4722   memcpy (concat_name, tmp, tmp_len);
4723   concat_name[tmp_len] = '/';
4724   strcpy (concat_name + tmp_len + 1, wrapper);
4725
4726   if (check_executable (concat_name))
4727     return concat_name;
4728   XFREE (concat_name);
4729   return NULL;
4730 }
4731
4732 char *
4733 chase_symlinks (const char *pathspec)
4734 {
4735 #ifndef S_ISLNK
4736   return xstrdup (pathspec);
4737 #else
4738   char buf[LT_PATHMAX];
4739   struct stat s;
4740   char *tmp_pathspec = xstrdup (pathspec);
4741   char *p;
4742   int has_symlinks = 0;
4743   while (strlen (tmp_pathspec) && !has_symlinks)
4744     {
4745       lt_debugprintf (__FILE__, __LINE__,
4746                       "checking path component for symlinks: %s\n",
4747                       tmp_pathspec);
4748       if (lstat (tmp_pathspec, &s) == 0)
4749         {
4750           if (S_ISLNK (s.st_mode) != 0)
4751             {
4752               has_symlinks = 1;
4753               break;
4754             }
4755
4756           /* search backwards for last DIR_SEPARATOR */
4757           p = tmp_pathspec + strlen (tmp_pathspec) - 1;
4758           while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4759             p--;
4760           if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4761             {
4762               /* no more DIR_SEPARATORS left */
4763               break;
4764             }
4765           *p = '\0';
4766         }
4767       else
4768         {
4769           lt_fatal (__FILE__, __LINE__,
4770                     "error accessing file \"%s\": %s",
4771                     tmp_pathspec, nonnull (strerror (errno)));
4772         }
4773     }
4774   XFREE (tmp_pathspec);
4775
4776   if (!has_symlinks)
4777     {
4778       return xstrdup (pathspec);
4779     }
4780
4781   tmp_pathspec = realpath (pathspec, buf);
4782   if (tmp_pathspec == 0)
4783     {
4784       lt_fatal (__FILE__, __LINE__,
4785                 "could not follow symlinks for %s", pathspec);
4786     }
4787   return xstrdup (tmp_pathspec);
4788 #endif
4789 }
4790
4791 char *
4792 strendzap (char *str, const char *pat)
4793 {
4794   size_t len, patlen;
4795
4796   assert (str != NULL);
4797   assert (pat != NULL);
4798
4799   len = strlen (str);
4800   patlen = strlen (pat);
4801
4802   if (patlen <= len)
4803     {
4804       str += len - patlen;
4805       if (strcmp (str, pat) == 0)
4806         *str = '\0';
4807     }
4808   return str;
4809 }
4810
4811 void
4812 lt_debugprintf (const char *file, int line, const char *fmt, ...)
4813 {
4814   va_list args;
4815   if (lt_debug)
4816     {
4817       (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
4818       va_start (args, fmt);
4819       (void) vfprintf (stderr, fmt, args);
4820       va_end (args);
4821     }
4822 }
4823
4824 static void
4825 lt_error_core (int exit_status, const char *file,
4826                int line, const char *mode,
4827                const char *message, va_list ap)
4828 {
4829   fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
4830   vfprintf (stderr, message, ap);
4831   fprintf (stderr, ".\n");
4832
4833   if (exit_status >= 0)
4834     exit (exit_status);
4835 }
4836
4837 void
4838 lt_fatal (const char *file, int line, const char *message, ...)
4839 {
4840   va_list ap;
4841   va_start (ap, message);
4842   lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
4843   va_end (ap);
4844 }
4845
4846 static const char *
4847 nonnull (const char *s)
4848 {
4849   return s ? s : "(null)";
4850 }
4851
4852 static const char *
4853 nonempty (const char *s)
4854 {
4855   return (s && !*s) ? "(empty)" : nonnull (s);
4856 }
4857
4858 void
4859 lt_setenv (const char *name, const char *value)
4860 {
4861   lt_debugprintf (__FILE__, __LINE__,
4862                   "(lt_setenv) setting '%s' to '%s'\n",
4863                   nonnull (name), nonnull (value));
4864   {
4865 #ifdef HAVE_SETENV
4866     /* always make a copy, for consistency with !HAVE_SETENV */
4867     char *str = xstrdup (value);
4868     setenv (name, str, 1);
4869 #else
4870     int len = strlen (name) + 1 + strlen (value) + 1;
4871     char *str = XMALLOC (char, len);
4872     sprintf (str, "%s=%s", name, value);
4873     if (putenv (str) != EXIT_SUCCESS)
4874       {
4875         XFREE (str);
4876       }
4877 #endif
4878   }
4879 }
4880
4881 char *
4882 lt_extend_str (const char *orig_value, const char *add, int to_end)
4883 {
4884   char *new_value;
4885   if (orig_value && *orig_value)
4886     {
4887       int orig_value_len = strlen (orig_value);
4888       int add_len = strlen (add);
4889       new_value = XMALLOC (char, add_len + orig_value_len + 1);
4890       if (to_end)
4891         {
4892           strcpy (new_value, orig_value);
4893           strcpy (new_value + orig_value_len, add);
4894         }
4895       else
4896         {
4897           strcpy (new_value, add);
4898           strcpy (new_value + add_len, orig_value);
4899         }
4900     }
4901   else
4902     {
4903       new_value = xstrdup (add);
4904     }
4905   return new_value;
4906 }
4907
4908 void
4909 lt_update_exe_path (const char *name, const char *value)
4910 {
4911   lt_debugprintf (__FILE__, __LINE__,
4912                   "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4913                   nonnull (name), nonnull (value));
4914
4915   if (name && *name && value && *value)
4916     {
4917       char *new_value = lt_extend_str (getenv (name), value, 0);
4918       /* some systems can't cope with a ':'-terminated path #' */
4919       int len = strlen (new_value);
4920       while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4921         {
4922           new_value[len-1] = '\0';
4923         }
4924       lt_setenv (name, new_value);
4925       XFREE (new_value);
4926     }
4927 }
4928
4929 void
4930 lt_update_lib_path (const char *name, const char *value)
4931 {
4932   lt_debugprintf (__FILE__, __LINE__,
4933                   "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4934                   nonnull (name), nonnull (value));
4935
4936   if (name && *name && value && *value)
4937     {
4938       char *new_value = lt_extend_str (getenv (name), value, 0);
4939       lt_setenv (name, new_value);
4940       XFREE (new_value);
4941     }
4942 }
4943
4944 EOF
4945             case $host_os in
4946               mingw*)
4947                 cat <<"EOF"
4948
4949 /* Prepares an argument vector before calling spawn().
4950    Note that spawn() does not by itself call the command interpreter
4951      (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4952       ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4953          GetVersionEx(&v);
4954          v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4955       }) ? "cmd.exe" : "command.com").
4956    Instead it simply concatenates the arguments, separated by ' ', and calls
4957    CreateProcess().  We must quote the arguments since Win32 CreateProcess()
4958    interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4959    special way:
4960    - Space and tab are interpreted as delimiters. They are not treated as
4961      delimiters if they are surrounded by double quotes: "...".
4962    - Unescaped double quotes are removed from the input. Their only effect is
4963      that within double quotes, space and tab are treated like normal
4964      characters.
4965    - Backslashes not followed by double quotes are not special.
4966    - But 2*n+1 backslashes followed by a double quote become
4967      n backslashes followed by a double quote (n >= 0):
4968        \" -> "
4969        \\\" -> \"
4970        \\\\\" -> \\"
4971  */
4972 #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"
4973 #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"
4974 char **
4975 prepare_spawn (char **argv)
4976 {
4977   size_t argc;
4978   char **new_argv;
4979   size_t i;
4980
4981   /* Count number of arguments.  */
4982   for (argc = 0; argv[argc] != NULL; argc++)
4983     ;
4984
4985   /* Allocate new argument vector.  */
4986   new_argv = XMALLOC (char *, argc + 1);
4987
4988   /* Put quoted arguments into the new argument vector.  */
4989   for (i = 0; i < argc; i++)
4990     {
4991       const char *string = argv[i];
4992
4993       if (string[0] == '\0')
4994         new_argv[i] = xstrdup ("\"\"");
4995       else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4996         {
4997           int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4998           size_t length;
4999           unsigned int backslashes;
5000           const char *s;
5001           char *quoted_string;
5002           char *p;
5003
5004           length = 0;
5005           backslashes = 0;
5006           if (quote_around)
5007             length++;
5008           for (s = string; *s != '\0'; s++)
5009             {
5010               char c = *s;
5011               if (c == '"')
5012                 length += backslashes + 1;
5013               length++;
5014               if (c == '\\')
5015                 backslashes++;
5016               else
5017                 backslashes = 0;
5018             }
5019           if (quote_around)
5020             length += backslashes + 1;
5021
5022           quoted_string = XMALLOC (char, length + 1);
5023
5024           p = quoted_string;
5025           backslashes = 0;
5026           if (quote_around)
5027             *p++ = '"';
5028           for (s = string; *s != '\0'; s++)
5029             {
5030               char c = *s;
5031               if (c == '"')
5032                 {
5033                   unsigned int j;
5034                   for (j = backslashes + 1; j > 0; j--)
5035                     *p++ = '\\';
5036                 }
5037               *p++ = c;
5038               if (c == '\\')
5039                 backslashes++;
5040               else
5041                 backslashes = 0;
5042             }
5043           if (quote_around)
5044             {
5045               unsigned int j;
5046               for (j = backslashes; j > 0; j--)
5047                 *p++ = '\\';
5048               *p++ = '"';
5049             }
5050           *p = '\0';
5051
5052           new_argv[i] = quoted_string;
5053         }
5054       else
5055         new_argv[i] = (char *) string;
5056     }
5057   new_argv[argc] = NULL;
5058
5059   return new_argv;
5060 }
5061 EOF
5062                 ;;
5063             esac
5064
5065             cat <<"EOF"
5066 void lt_dump_script (FILE* f)
5067 {
5068 EOF
5069             func_emit_wrapper yes |
5070               $SED -e 's/\([\\"]\)/\\\1/g' \
5071                    -e 's/^/  fputs ("/' -e 's/$/\\n", f);/'
5072
5073             cat <<"EOF"
5074 }
5075 EOF
5076 }
5077 # end: func_emit_cwrapperexe_src
5078
5079 # func_win32_import_lib_p ARG
5080 # True if ARG is an import lib, as indicated by $file_magic_cmd
5081 func_win32_import_lib_p ()
5082 {
5083     $opt_debug
5084     case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
5085     *import*) : ;;
5086     *) false ;;
5087     esac
5088 }
5089
5090 # func_mode_link arg...
5091 func_mode_link ()
5092 {
5093     $opt_debug
5094     case $host in
5095     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5096       # It is impossible to link a dll without this setting, and
5097       # we shouldn't force the makefile maintainer to figure out
5098       # which system we are compiling for in order to pass an extra
5099       # flag for every libtool invocation.
5100       # allow_undefined=no
5101
5102       # FIXME: Unfortunately, there are problems with the above when trying
5103       # to make a dll which has undefined symbols, in which case not
5104       # even a static library is built.  For now, we need to specify
5105       # -no-undefined on the libtool link line when we can be certain
5106       # that all symbols are satisfied, otherwise we get a static library.
5107       allow_undefined=yes
5108       ;;
5109     *)
5110       allow_undefined=yes
5111       ;;
5112     esac
5113     libtool_args=$nonopt
5114     base_compile="$nonopt $@"
5115     compile_command=$nonopt
5116     finalize_command=$nonopt
5117
5118     compile_rpath=
5119     finalize_rpath=
5120     compile_shlibpath=
5121     finalize_shlibpath=
5122     convenience=
5123     old_convenience=
5124     deplibs=
5125     old_deplibs=
5126     compiler_flags=
5127     linker_flags=
5128     dllsearchpath=
5129     lib_search_path=`pwd`
5130     inst_prefix_dir=
5131     new_inherited_linker_flags=
5132
5133     avoid_version=no
5134     bindir=
5135     dlfiles=
5136     dlprefiles=
5137     dlself=no
5138     export_dynamic=no
5139     export_symbols=
5140     export_symbols_regex=
5141     generated=
5142     libobjs=
5143     ltlibs=
5144     module=no
5145     no_install=no
5146     objs=
5147     non_pic_objects=
5148     precious_files_regex=
5149     prefer_static_libs=no
5150     preload=no
5151     prev=
5152     prevarg=
5153     release=
5154     rpath=
5155     xrpath=
5156     perm_rpath=
5157     temp_rpath=
5158     thread_safe=no
5159     vinfo=
5160     vinfo_number=no
5161     weak_libs=
5162     single_module="${wl}-single_module"
5163     func_infer_tag $base_compile
5164
5165     # We need to know -static, to get the right output filenames.
5166     for arg
5167     do
5168       case $arg in
5169       -shared)
5170         test "$build_libtool_libs" != yes && \
5171           func_fatal_configuration "can not build a shared library"
5172         build_old_libs=no
5173         break
5174         ;;
5175       -all-static | -static | -static-libtool-libs)
5176         case $arg in
5177         -all-static)
5178           if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
5179             func_warning "complete static linking is impossible in this configuration"
5180           fi
5181           if test -n "$link_static_flag"; then
5182             dlopen_self=$dlopen_self_static
5183           fi
5184           prefer_static_libs=yes
5185           ;;
5186         -static)
5187           if test -z "$pic_flag" && test -n "$link_static_flag"; then
5188             dlopen_self=$dlopen_self_static
5189           fi
5190           prefer_static_libs=built
5191           ;;
5192         -static-libtool-libs)
5193           if test -z "$pic_flag" && test -n "$link_static_flag"; then
5194             dlopen_self=$dlopen_self_static
5195           fi
5196           prefer_static_libs=yes
5197           ;;
5198         esac
5199         build_libtool_libs=no
5200         build_old_libs=yes
5201         break
5202         ;;
5203       esac
5204     done
5205
5206     # See if our shared archives depend on static archives.
5207     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
5208
5209     # Go through the arguments, transforming them on the way.
5210     while test "$#" -gt 0; do
5211       arg="$1"
5212       shift
5213       func_quote_for_eval "$arg"
5214       qarg=$func_quote_for_eval_unquoted_result
5215       func_append libtool_args " $func_quote_for_eval_result"
5216
5217       # If the previous option needs an argument, assign it.
5218       if test -n "$prev"; then
5219         case $prev in
5220         output)
5221           func_append compile_command " @OUTPUT@"
5222           func_append finalize_command " @OUTPUT@"
5223           ;;
5224         esac
5225
5226         case $prev in
5227         bindir)
5228           bindir="$arg"
5229           prev=
5230           continue
5231           ;;
5232         dlfiles|dlprefiles)
5233           if test "$preload" = no; then
5234             # Add the symbol object into the linking commands.
5235             func_append compile_command " @SYMFILE@"
5236             func_append finalize_command " @SYMFILE@"
5237             preload=yes
5238           fi
5239           case $arg in
5240           *.la | *.lo) ;;  # We handle these cases below.
5241           force)
5242             if test "$dlself" = no; then
5243               dlself=needless
5244               export_dynamic=yes
5245             fi
5246             prev=
5247             continue
5248             ;;
5249           self)
5250             if test "$prev" = dlprefiles; then
5251               dlself=yes
5252             elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
5253               dlself=yes
5254             else
5255               dlself=needless
5256               export_dynamic=yes
5257             fi
5258             prev=
5259             continue
5260             ;;
5261           *)
5262             if test "$prev" = dlfiles; then
5263               func_append dlfiles " $arg"
5264             else
5265               func_append dlprefiles " $arg"
5266             fi
5267             prev=
5268             continue
5269             ;;
5270           esac
5271           ;;
5272         expsyms)
5273           export_symbols="$arg"
5274           test -f "$arg" \
5275             || func_fatal_error "symbol file \`$arg' does not exist"
5276           prev=
5277           continue
5278           ;;
5279         expsyms_regex)
5280           export_symbols_regex="$arg"
5281           prev=
5282           continue
5283           ;;
5284         framework)
5285           case $host in
5286             *-*-darwin*)
5287               case "$deplibs " in
5288                 *" $qarg.ltframework "*) ;;
5289                 *) func_append deplibs " $qarg.ltframework" # this is fixed later
5290                    ;;
5291               esac
5292               ;;
5293           esac
5294           prev=
5295           continue
5296           ;;
5297         inst_prefix)
5298           inst_prefix_dir="$arg"
5299           prev=
5300           continue
5301           ;;
5302         objectlist)
5303           if test -f "$arg"; then
5304             save_arg=$arg
5305             moreargs=
5306             for fil in `cat "$save_arg"`
5307             do
5308 #             func_append moreargs " $fil"
5309               arg=$fil
5310               # A libtool-controlled object.
5311
5312               # Check to see that this really is a libtool object.
5313               if func_lalib_unsafe_p "$arg"; then
5314                 pic_object=
5315                 non_pic_object=
5316
5317                 # Read the .lo file
5318                 func_source "$arg"
5319
5320                 if test -z "$pic_object" ||
5321                    test -z "$non_pic_object" ||
5322                    test "$pic_object" = none &&
5323                    test "$non_pic_object" = none; then
5324                   func_fatal_error "cannot find name of object for \`$arg'"
5325                 fi
5326
5327                 # Extract subdirectory from the argument.
5328                 func_dirname "$arg" "/" ""
5329                 xdir="$func_dirname_result"
5330
5331                 if test "$pic_object" != none; then
5332                   # Prepend the subdirectory the object is found in.
5333                   pic_object="$xdir$pic_object"
5334
5335                   if test "$prev" = dlfiles; then
5336                     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5337                       func_append dlfiles " $pic_object"
5338                       prev=
5339                       continue
5340                     else
5341                       # If libtool objects are unsupported, then we need to preload.
5342                       prev=dlprefiles
5343                     fi
5344                   fi
5345
5346                   # CHECK ME:  I think I busted this.  -Ossama
5347                   if test "$prev" = dlprefiles; then
5348                     # Preload the old-style object.
5349                     func_append dlprefiles " $pic_object"
5350                     prev=
5351                   fi
5352
5353                   # A PIC object.
5354                   func_append libobjs " $pic_object"
5355                   arg="$pic_object"
5356                 fi
5357
5358                 # Non-PIC object.
5359                 if test "$non_pic_object" != none; then
5360                   # Prepend the subdirectory the object is found in.
5361                   non_pic_object="$xdir$non_pic_object"
5362
5363                   # A standard non-PIC object
5364                   func_append non_pic_objects " $non_pic_object"
5365                   if test -z "$pic_object" || test "$pic_object" = none ; then
5366                     arg="$non_pic_object"
5367                   fi
5368                 else
5369                   # If the PIC object exists, use it instead.
5370                   # $xdir was prepended to $pic_object above.
5371                   non_pic_object="$pic_object"
5372                   func_append non_pic_objects " $non_pic_object"
5373                 fi
5374               else
5375                 # Only an error if not doing a dry-run.
5376                 if $opt_dry_run; then
5377                   # Extract subdirectory from the argument.
5378                   func_dirname "$arg" "/" ""
5379                   xdir="$func_dirname_result"
5380
5381                   func_lo2o "$arg"
5382                   pic_object=$xdir$objdir/$func_lo2o_result
5383                   non_pic_object=$xdir$func_lo2o_result
5384                   func_append libobjs " $pic_object"
5385                   func_append non_pic_objects " $non_pic_object"
5386                 else
5387                   func_fatal_error "\`$arg' is not a valid libtool object"
5388                 fi
5389               fi
5390             done
5391           else
5392             func_fatal_error "link input file \`$arg' does not exist"
5393           fi
5394           arg=$save_arg
5395           prev=
5396           continue
5397           ;;
5398         precious_regex)
5399           precious_files_regex="$arg"
5400           prev=
5401           continue
5402           ;;
5403         release)
5404           release="-$arg"
5405           prev=
5406           continue
5407           ;;
5408         rpath | xrpath)
5409           # We need an absolute path.
5410           case $arg in
5411           [\\/]* | [A-Za-z]:[\\/]*) ;;
5412           *)
5413             func_fatal_error "only absolute run-paths are allowed"
5414             ;;
5415           esac
5416           if test "$prev" = rpath; then
5417             case "$rpath " in
5418             *" $arg "*) ;;
5419             *) func_append rpath " $arg" ;;
5420             esac
5421           else
5422             case "$xrpath " in
5423             *" $arg "*) ;;
5424             *) func_append xrpath " $arg" ;;
5425             esac
5426           fi
5427           prev=
5428           continue
5429           ;;
5430         shrext)
5431           shrext_cmds="$arg"
5432           prev=
5433           continue
5434           ;;
5435         weak)
5436           func_append weak_libs " $arg"
5437           prev=
5438           continue
5439           ;;
5440         xcclinker)
5441           func_append linker_flags " $qarg"
5442           func_append compiler_flags " $qarg"
5443           prev=
5444           func_append compile_command " $qarg"
5445           func_append finalize_command " $qarg"
5446           continue
5447           ;;
5448         xcompiler)
5449           func_append compiler_flags " $qarg"
5450           prev=
5451           func_append compile_command " $qarg"
5452           func_append finalize_command " $qarg"
5453           continue
5454           ;;
5455         xlinker)
5456           func_append linker_flags " $qarg"
5457           func_append compiler_flags " $wl$qarg"
5458           prev=
5459           func_append compile_command " $wl$qarg"
5460           func_append finalize_command " $wl$qarg"
5461           continue
5462           ;;
5463         *)
5464           eval "$prev=\"\$arg\""
5465           prev=
5466           continue
5467           ;;
5468         esac
5469       fi # test -n "$prev"
5470
5471       prevarg="$arg"
5472
5473       case $arg in
5474       -all-static)
5475         if test -n "$link_static_flag"; then
5476           # See comment for -static flag below, for more details.
5477           func_append compile_command " $link_static_flag"
5478           func_append finalize_command " $link_static_flag"
5479         fi
5480         continue
5481         ;;
5482
5483       -allow-undefined)
5484         # FIXME: remove this flag sometime in the future.
5485         func_fatal_error "\`-allow-undefined' must not be used because it is the default"
5486         ;;
5487
5488       -avoid-version)
5489         avoid_version=yes
5490         continue
5491         ;;
5492
5493       -bindir)
5494         prev=bindir
5495         continue
5496         ;;
5497
5498       -dlopen)
5499         prev=dlfiles
5500         continue
5501         ;;
5502
5503       -dlpreopen)
5504         prev=dlprefiles
5505         continue
5506         ;;
5507
5508       -export-dynamic)
5509         export_dynamic=yes
5510         continue
5511         ;;
5512
5513       -export-symbols | -export-symbols-regex)
5514         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
5515           func_fatal_error "more than one -exported-symbols argument is not allowed"
5516         fi
5517         if test "X$arg" = "X-export-symbols"; then
5518           prev=expsyms
5519         else
5520           prev=expsyms_regex
5521         fi
5522         continue
5523         ;;
5524
5525       -framework)
5526         prev=framework
5527         continue
5528         ;;
5529
5530       -inst-prefix-dir)
5531         prev=inst_prefix
5532         continue
5533         ;;
5534
5535       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
5536       # so, if we see these flags be careful not to treat them like -L
5537       -L[A-Z][A-Z]*:*)
5538         case $with_gcc/$host in
5539         no/*-*-irix* | /*-*-irix*)
5540           func_append compile_command " $arg"
5541           func_append finalize_command " $arg"
5542           ;;
5543         esac
5544         continue
5545         ;;
5546
5547       -L*)
5548         func_stripname "-L" '' "$arg"
5549         if test -z "$func_stripname_result"; then
5550           if test "$#" -gt 0; then
5551             func_fatal_error "require no space between \`-L' and \`$1'"
5552           else
5553             func_fatal_error "need path for \`-L' option"
5554           fi
5555         fi
5556         func_resolve_sysroot "$func_stripname_result"
5557         dir=$func_resolve_sysroot_result
5558         # We need an absolute path.
5559         case $dir in
5560         [\\/]* | [A-Za-z]:[\\/]*) ;;
5561         *)
5562           absdir=`cd "$dir" && pwd`
5563           test -z "$absdir" && \
5564             func_fatal_error "cannot determine absolute directory name of \`$dir'"
5565           dir="$absdir"
5566           ;;
5567         esac
5568         case "$deplibs " in
5569         *" -L$dir "* | *" $arg "*)
5570           # Will only happen for absolute or sysroot arguments
5571           ;;
5572         *)
5573           # Preserve sysroot, but never include relative directories
5574           case $dir in
5575             [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
5576             *) func_append deplibs " -L$dir" ;;
5577           esac
5578           func_append lib_search_path " $dir"
5579           ;;
5580         esac
5581         case $host in
5582         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5583           testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
5584           case :$dllsearchpath: in
5585           *":$dir:"*) ;;
5586           ::) dllsearchpath=$dir;;
5587           *) func_append dllsearchpath ":$dir";;
5588           esac
5589           case :$dllsearchpath: in
5590           *":$testbindir:"*) ;;
5591           ::) dllsearchpath=$testbindir;;
5592           *) func_append dllsearchpath ":$testbindir";;
5593           esac
5594           ;;
5595         esac
5596         continue
5597         ;;
5598
5599       -l*)
5600         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
5601           case $host in
5602           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
5603             # These systems don't actually have a C or math library (as such)
5604             continue
5605             ;;
5606           *-*-os2*)
5607             # These systems don't actually have a C library (as such)
5608             test "X$arg" = "X-lc" && continue
5609             ;;
5610           *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5611             # Do not include libc due to us having libc/libc_r.
5612             test "X$arg" = "X-lc" && continue
5613             ;;
5614           *-*-rhapsody* | *-*-darwin1.[012])
5615             # Rhapsody C and math libraries are in the System framework
5616             func_append deplibs " System.ltframework"
5617             continue
5618             ;;
5619           *-*-sco3.2v5* | *-*-sco5v6*)
5620             # Causes problems with __ctype
5621             test "X$arg" = "X-lc" && continue
5622             ;;
5623           *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5624             # Compiler inserts libc in the correct place for threads to work
5625             test "X$arg" = "X-lc" && continue
5626             ;;
5627           esac
5628         elif test "X$arg" = "X-lc_r"; then
5629          case $host in
5630          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5631            # Do not include libc_r directly, use -pthread flag.
5632            continue
5633            ;;
5634          esac
5635         fi
5636         func_append deplibs " $arg"
5637         continue
5638         ;;
5639
5640       -module)
5641         module=yes
5642         continue
5643         ;;
5644
5645       # Tru64 UNIX uses -model [arg] to determine the layout of C++
5646       # classes, name mangling, and exception handling.
5647       # Darwin uses the -arch flag to determine output architecture.
5648       -model|-arch|-isysroot|--sysroot)
5649         func_append compiler_flags " $arg"
5650         func_append compile_command " $arg"
5651         func_append finalize_command " $arg"
5652         prev=xcompiler
5653         continue
5654         ;;
5655
5656       -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5657         func_append compiler_flags " $arg"
5658         func_append compile_command " $arg"
5659         func_append finalize_command " $arg"
5660         case "$new_inherited_linker_flags " in
5661             *" $arg "*) ;;
5662             * ) func_append new_inherited_linker_flags " $arg" ;;
5663         esac
5664         continue
5665         ;;
5666
5667       -multi_module)
5668         single_module="${wl}-multi_module"
5669         continue
5670         ;;
5671
5672       -no-fast-install)
5673         fast_install=no
5674         continue
5675         ;;
5676
5677       -no-install)
5678         case $host in
5679         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
5680           # The PATH hackery in wrapper scripts is required on Windows
5681           # and Darwin in order for the loader to find any dlls it needs.
5682           func_warning "\`-no-install' is ignored for $host"
5683           func_warning "assuming \`-no-fast-install' instead"
5684           fast_install=no
5685           ;;
5686         *) no_install=yes ;;
5687         esac
5688         continue
5689         ;;
5690
5691       -no-undefined)
5692         allow_undefined=no
5693         continue
5694         ;;
5695
5696       -objectlist)
5697         prev=objectlist
5698         continue
5699         ;;
5700
5701       -o) prev=output ;;
5702
5703       -precious-files-regex)
5704         prev=precious_regex
5705         continue
5706         ;;
5707
5708       -release)
5709         prev=release
5710         continue
5711         ;;
5712
5713       -rpath)
5714         prev=rpath
5715         continue
5716         ;;
5717
5718       -R)
5719         prev=xrpath
5720         continue
5721         ;;
5722
5723       -R*)
5724         func_stripname '-R' '' "$arg"
5725         dir=$func_stripname_result
5726         # We need an absolute path.
5727         case $dir in
5728         [\\/]* | [A-Za-z]:[\\/]*) ;;
5729         =*)
5730           func_stripname '=' '' "$dir"
5731           dir=$lt_sysroot$func_stripname_result
5732           ;;
5733         *)
5734           func_fatal_error "only absolute run-paths are allowed"
5735           ;;
5736         esac
5737         case "$xrpath " in
5738         *" $dir "*) ;;
5739         *) func_append xrpath " $dir" ;;
5740         esac
5741         continue
5742         ;;
5743
5744       -shared)
5745         # The effects of -shared are defined in a previous loop.
5746         continue
5747         ;;
5748
5749       -shrext)
5750         prev=shrext
5751         continue
5752         ;;
5753
5754       -static | -static-libtool-libs)
5755         # The effects of -static are defined in a previous loop.
5756         # We used to do the same as -all-static on platforms that
5757         # didn't have a PIC flag, but the assumption that the effects
5758         # would be equivalent was wrong.  It would break on at least
5759         # Digital Unix and AIX.
5760         continue
5761         ;;
5762
5763       -thread-safe)
5764         thread_safe=yes
5765         continue
5766         ;;
5767
5768       -version-info)
5769         prev=vinfo
5770         continue
5771         ;;
5772
5773       -version-number)
5774         prev=vinfo
5775         vinfo_number=yes
5776         continue
5777         ;;
5778
5779       -weak)
5780         prev=weak
5781         continue
5782         ;;
5783
5784       -Wc,*)
5785         func_stripname '-Wc,' '' "$arg"
5786         args=$func_stripname_result
5787         arg=
5788         save_ifs="$IFS"; IFS=','
5789         for flag in $args; do
5790           IFS="$save_ifs"
5791           func_quote_for_eval "$flag"
5792           func_append arg " $func_quote_for_eval_result"
5793           func_append compiler_flags " $func_quote_for_eval_result"
5794         done
5795         IFS="$save_ifs"
5796         func_stripname ' ' '' "$arg"
5797         arg=$func_stripname_result
5798         ;;
5799
5800       -Wl,*)
5801         func_stripname '-Wl,' '' "$arg"
5802         args=$func_stripname_result
5803         arg=
5804         save_ifs="$IFS"; IFS=','
5805         for flag in $args; do
5806           IFS="$save_ifs"
5807           func_quote_for_eval "$flag"
5808           func_append arg " $wl$func_quote_for_eval_result"
5809           func_append compiler_flags " $wl$func_quote_for_eval_result"
5810           func_append linker_flags " $func_quote_for_eval_result"
5811         done
5812         IFS="$save_ifs"
5813         func_stripname ' ' '' "$arg"
5814         arg=$func_stripname_result
5815         ;;
5816
5817       -Xcompiler)
5818         prev=xcompiler
5819         continue
5820         ;;
5821
5822       -Xlinker)
5823         prev=xlinker
5824         continue
5825         ;;
5826
5827       -XCClinker)
5828         prev=xcclinker
5829         continue
5830         ;;
5831
5832       # -msg_* for osf cc
5833       -msg_*)
5834         func_quote_for_eval "$arg"
5835         arg="$func_quote_for_eval_result"
5836         ;;
5837
5838       # Flags to be passed through unchanged, with rationale:
5839       # -64, -mips[0-9]      enable 64-bit mode for the SGI compiler
5840       # -r[0-9][0-9]*        specify processor for the SGI compiler
5841       # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
5842       # +DA*, +DD*           enable 64-bit mode for the HP compiler
5843       # -q*                  compiler args for the IBM compiler
5844       # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
5845       # -F/path              path to uninstalled frameworks, gcc on darwin
5846       # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
5847       # @file                GCC response files
5848       # -tp=*                Portland pgcc target processor selection
5849       # --sysroot=*          for sysroot support
5850       # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
5851       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
5852       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
5853       -O*|-flto*|-fwhopr*|-fuse-linker-plugin)
5854         func_quote_for_eval "$arg"
5855         arg="$func_quote_for_eval_result"
5856         func_append compile_command " $arg"
5857         func_append finalize_command " $arg"
5858         func_append compiler_flags " $arg"
5859         continue
5860         ;;
5861
5862       # Some other compiler flag.
5863       -* | +*)
5864         func_quote_for_eval "$arg"
5865         arg="$func_quote_for_eval_result"
5866         ;;
5867
5868       *.$objext)
5869         # A standard object.
5870         func_append objs " $arg"
5871         ;;
5872
5873       *.lo)
5874         # A libtool-controlled object.
5875
5876         # Check to see that this really is a libtool object.
5877         if func_lalib_unsafe_p "$arg"; then
5878           pic_object=
5879           non_pic_object=
5880
5881           # Read the .lo file
5882           func_source "$arg"
5883
5884           if test -z "$pic_object" ||
5885              test -z "$non_pic_object" ||
5886              test "$pic_object" = none &&
5887              test "$non_pic_object" = none; then
5888             func_fatal_error "cannot find name of object for \`$arg'"
5889           fi
5890
5891           # Extract subdirectory from the argument.
5892           func_dirname "$arg" "/" ""
5893           xdir="$func_dirname_result"
5894
5895           if test "$pic_object" != none; then
5896             # Prepend the subdirectory the object is found in.
5897             pic_object="$xdir$pic_object"
5898
5899             if test "$prev" = dlfiles; then
5900               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5901                 func_append dlfiles " $pic_object"
5902                 prev=
5903                 continue
5904               else
5905                 # If libtool objects are unsupported, then we need to preload.
5906                 prev=dlprefiles
5907               fi
5908             fi
5909
5910             # CHECK ME:  I think I busted this.  -Ossama
5911             if test "$prev" = dlprefiles; then
5912               # Preload the old-style object.
5913               func_append dlprefiles " $pic_object"
5914               prev=
5915             fi
5916
5917             # A PIC object.
5918             func_append libobjs " $pic_object"
5919             arg="$pic_object"
5920           fi
5921
5922           # Non-PIC object.
5923           if test "$non_pic_object" != none; then
5924             # Prepend the subdirectory the object is found in.
5925             non_pic_object="$xdir$non_pic_object"
5926
5927             # A standard non-PIC object
5928             func_append non_pic_objects " $non_pic_object"
5929             if test -z "$pic_object" || test "$pic_object" = none ; then
5930               arg="$non_pic_object"
5931             fi
5932           else
5933             # If the PIC object exists, use it instead.
5934             # $xdir was prepended to $pic_object above.
5935             non_pic_object="$pic_object"
5936             func_append non_pic_objects " $non_pic_object"
5937           fi
5938         else
5939           # Only an error if not doing a dry-run.
5940           if $opt_dry_run; then
5941             # Extract subdirectory from the argument.
5942             func_dirname "$arg" "/" ""
5943             xdir="$func_dirname_result"
5944
5945             func_lo2o "$arg"
5946             pic_object=$xdir$objdir/$func_lo2o_result
5947             non_pic_object=$xdir$func_lo2o_result
5948             func_append libobjs " $pic_object"
5949             func_append non_pic_objects " $non_pic_object"
5950           else
5951             func_fatal_error "\`$arg' is not a valid libtool object"
5952           fi
5953         fi
5954         ;;
5955
5956       *.$libext)
5957         # An archive.
5958         func_append deplibs " $arg"
5959         func_append old_deplibs " $arg"
5960         continue
5961         ;;
5962
5963       *.la)
5964         # A libtool-controlled library.
5965
5966         func_resolve_sysroot "$arg"
5967         if test "$prev" = dlfiles; then
5968           # This library was specified with -dlopen.
5969           func_append dlfiles " $func_resolve_sysroot_result"
5970           prev=
5971         elif test "$prev" = dlprefiles; then
5972           # The library was specified with -dlpreopen.
5973           func_append dlprefiles " $func_resolve_sysroot_result"
5974           prev=
5975         else
5976           func_append deplibs " $func_resolve_sysroot_result"
5977         fi
5978         continue
5979         ;;
5980
5981       # Some other compiler argument.
5982       *)
5983         # Unknown arguments in both finalize_command and compile_command need
5984         # to be aesthetically quoted because they are evaled later.
5985         func_quote_for_eval "$arg"
5986         arg="$func_quote_for_eval_result"
5987         ;;
5988       esac # arg
5989
5990       # Now actually substitute the argument into the commands.
5991       if test -n "$arg"; then
5992         func_append compile_command " $arg"
5993         func_append finalize_command " $arg"
5994       fi
5995     done # argument parsing loop
5996
5997     test -n "$prev" && \
5998       func_fatal_help "the \`$prevarg' option requires an argument"
5999
6000     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
6001       eval arg=\"$export_dynamic_flag_spec\"
6002       func_append compile_command " $arg"
6003       func_append finalize_command " $arg"
6004     fi
6005
6006     oldlibs=
6007     # calculate the name of the file, without its directory
6008     func_basename "$output"
6009     outputname="$func_basename_result"
6010     libobjs_save="$libobjs"
6011
6012     if test -n "$shlibpath_var"; then
6013       # get the directories listed in $shlibpath_var
6014       eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
6015     else
6016       shlib_search_path=
6017     fi
6018     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
6019     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
6020
6021     func_dirname "$output" "/" ""
6022     output_objdir="$func_dirname_result$objdir"
6023     func_to_tool_file "$output_objdir/"
6024     tool_output_objdir=$func_to_tool_file_result
6025     # Create the object directory.
6026     func_mkdir_p "$output_objdir"
6027
6028     # Determine the type of output
6029     case $output in
6030     "")
6031       func_fatal_help "you must specify an output file"
6032       ;;
6033     *.$libext) linkmode=oldlib ;;
6034     *.lo | *.$objext) linkmode=obj ;;
6035     *.la) linkmode=lib ;;
6036     *) linkmode=prog ;; # Anything else should be a program.
6037     esac
6038
6039     specialdeplibs=
6040
6041     libs=
6042     # Find all interdependent deplibs by searching for libraries
6043     # that are linked more than once (e.g. -la -lb -la)
6044     for deplib in $deplibs; do
6045       if $opt_preserve_dup_deps ; then
6046         case "$libs " in
6047         *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6048         esac
6049       fi
6050       func_append libs " $deplib"
6051     done
6052
6053     if test "$linkmode" = lib; then
6054       libs="$predeps $libs $compiler_lib_search_path $postdeps"
6055
6056       # Compute libraries that are listed more than once in $predeps
6057       # $postdeps and mark them as special (i.e., whose duplicates are
6058       # not to be eliminated).
6059       pre_post_deps=
6060       if $opt_duplicate_compiler_generated_deps; then
6061         for pre_post_dep in $predeps $postdeps; do
6062           case "$pre_post_deps " in
6063           *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
6064           esac
6065           func_append pre_post_deps " $pre_post_dep"
6066         done
6067       fi
6068       pre_post_deps=
6069     fi
6070
6071     deplibs=
6072     newdependency_libs=
6073     newlib_search_path=
6074     need_relink=no # whether we're linking any uninstalled libtool libraries
6075     notinst_deplibs= # not-installed libtool libraries
6076     notinst_path= # paths that contain not-installed libtool libraries
6077
6078     case $linkmode in
6079     lib)
6080         passes="conv dlpreopen link"
6081         for file in $dlfiles $dlprefiles; do
6082           case $file in
6083           *.la) ;;
6084           *)
6085             func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
6086             ;;
6087           esac
6088         done
6089         ;;
6090     prog)
6091         compile_deplibs=
6092         finalize_deplibs=
6093         alldeplibs=no
6094         newdlfiles=
6095         newdlprefiles=
6096         passes="conv scan dlopen dlpreopen link"
6097         ;;
6098     *)  passes="conv"
6099         ;;
6100     esac
6101
6102     for pass in $passes; do
6103       # The preopen pass in lib mode reverses $deplibs; put it back here
6104       # so that -L comes before libs that need it for instance...
6105       if test "$linkmode,$pass" = "lib,link"; then
6106         ## FIXME: Find the place where the list is rebuilt in the wrong
6107         ##        order, and fix it there properly
6108         tmp_deplibs=
6109         for deplib in $deplibs; do
6110           tmp_deplibs="$deplib $tmp_deplibs"
6111         done
6112         deplibs="$tmp_deplibs"
6113       fi
6114
6115       if test "$linkmode,$pass" = "lib,link" ||
6116          test "$linkmode,$pass" = "prog,scan"; then
6117         libs="$deplibs"
6118         deplibs=
6119       fi
6120       if test "$linkmode" = prog; then
6121         case $pass in
6122         dlopen) libs="$dlfiles" ;;
6123         dlpreopen) libs="$dlprefiles" ;;
6124         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
6125         esac
6126       fi
6127       if test "$linkmode,$pass" = "lib,dlpreopen"; then
6128         # Collect and forward deplibs of preopened libtool libs
6129         for lib in $dlprefiles; do
6130           # Ignore non-libtool-libs
6131           dependency_libs=
6132           func_resolve_sysroot "$lib"
6133           case $lib in
6134           *.la) func_source "$func_resolve_sysroot_result" ;;
6135           esac
6136
6137           # Collect preopened libtool deplibs, except any this library
6138           # has declared as weak libs
6139           for deplib in $dependency_libs; do
6140             func_basename "$deplib"
6141             deplib_base=$func_basename_result
6142             case " $weak_libs " in
6143             *" $deplib_base "*) ;;
6144             *) func_append deplibs " $deplib" ;;
6145             esac
6146           done
6147         done
6148         libs="$dlprefiles"
6149       fi
6150       if test "$pass" = dlopen; then
6151         # Collect dlpreopened libraries
6152         save_deplibs="$deplibs"
6153         deplibs=
6154       fi
6155
6156       for deplib in $libs; do
6157         lib=
6158         found=no
6159         case $deplib in
6160         -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
6161           if test "$linkmode,$pass" = "prog,link"; then
6162             compile_deplibs="$deplib $compile_deplibs"
6163             finalize_deplibs="$deplib $finalize_deplibs"
6164           else
6165             func_append compiler_flags " $deplib"
6166             if test "$linkmode" = lib ; then
6167                 case "$new_inherited_linker_flags " in
6168                     *" $deplib "*) ;;
6169                     * ) func_append new_inherited_linker_flags " $deplib" ;;
6170                 esac
6171             fi
6172           fi
6173           continue
6174           ;;
6175         -l*)
6176           if test "$linkmode" != lib && test "$linkmode" != prog; then
6177             func_warning "\`-l' is ignored for archives/objects"
6178             continue
6179           fi
6180           func_stripname '-l' '' "$deplib"
6181           name=$func_stripname_result
6182           if test "$linkmode" = lib; then
6183             searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
6184           else
6185             searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
6186           fi
6187           for searchdir in $searchdirs; do
6188             for search_ext in .la $std_shrext .so .a; do
6189               # Search the libtool library
6190               lib="$searchdir/lib${name}${search_ext}"
6191               if test -f "$lib"; then
6192                 if test "$search_ext" = ".la"; then
6193                   found=yes
6194                 else
6195                   found=no
6196                 fi
6197                 break 2
6198               fi
6199             done
6200           done
6201           if test "$found" != yes; then
6202             # deplib doesn't seem to be a libtool library
6203             if test "$linkmode,$pass" = "prog,link"; then
6204               compile_deplibs="$deplib $compile_deplibs"
6205               finalize_deplibs="$deplib $finalize_deplibs"
6206             else
6207               deplibs="$deplib $deplibs"
6208               test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6209             fi
6210             continue
6211           else # deplib is a libtool library
6212             # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
6213             # We need to do some special things here, and not later.
6214             if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6215               case " $predeps $postdeps " in
6216               *" $deplib "*)
6217                 if func_lalib_p "$lib"; then
6218                   library_names=
6219                   old_library=
6220                   func_source "$lib"
6221                   for l in $old_library $library_names; do
6222                     ll="$l"
6223                   done
6224                   if test "X$ll" = "X$old_library" ; then # only static version available
6225                     found=no
6226                     func_dirname "$lib" "" "."
6227                     ladir="$func_dirname_result"
6228                     lib=$ladir/$old_library
6229                     if test "$linkmode,$pass" = "prog,link"; then
6230                       compile_deplibs="$deplib $compile_deplibs"
6231                       finalize_deplibs="$deplib $finalize_deplibs"
6232                     else
6233                       deplibs="$deplib $deplibs"
6234                       test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6235                     fi
6236                     continue
6237                   fi
6238                 fi
6239                 ;;
6240               *) ;;
6241               esac
6242             fi
6243           fi
6244           ;; # -l
6245         *.ltframework)
6246           if test "$linkmode,$pass" = "prog,link"; then
6247             compile_deplibs="$deplib $compile_deplibs"
6248             finalize_deplibs="$deplib $finalize_deplibs"
6249           else
6250             deplibs="$deplib $deplibs"
6251             if test "$linkmode" = lib ; then
6252                 case "$new_inherited_linker_flags " in
6253                     *" $deplib "*) ;;
6254                     * ) func_append new_inherited_linker_flags " $deplib" ;;
6255                 esac
6256             fi
6257           fi
6258           continue
6259           ;;
6260         -L*)
6261           case $linkmode in
6262           lib)
6263             deplibs="$deplib $deplibs"
6264             test "$pass" = conv && continue
6265             newdependency_libs="$deplib $newdependency_libs"
6266             func_stripname '-L' '' "$deplib"
6267             func_resolve_sysroot "$func_stripname_result"
6268             func_append newlib_search_path " $func_resolve_sysroot_result"
6269             ;;
6270           prog)
6271             if test "$pass" = conv; then
6272               deplibs="$deplib $deplibs"
6273               continue
6274             fi
6275             if test "$pass" = scan; then
6276               deplibs="$deplib $deplibs"
6277             else
6278               compile_deplibs="$deplib $compile_deplibs"
6279               finalize_deplibs="$deplib $finalize_deplibs"
6280             fi
6281             func_stripname '-L' '' "$deplib"
6282             func_resolve_sysroot "$func_stripname_result"
6283             func_append newlib_search_path " $func_resolve_sysroot_result"
6284             ;;
6285           *)
6286             func_warning "\`-L' is ignored for archives/objects"
6287             ;;
6288           esac # linkmode
6289           continue
6290           ;; # -L
6291         -R*)
6292           if test "$pass" = link; then
6293             func_stripname '-R' '' "$deplib"
6294             func_resolve_sysroot "$func_stripname_result"
6295             dir=$func_resolve_sysroot_result
6296             # Make sure the xrpath contains only unique directories.
6297             case "$xrpath " in
6298             *" $dir "*) ;;
6299             *) func_append xrpath " $dir" ;;
6300             esac
6301           fi
6302           deplibs="$deplib $deplibs"
6303           continue
6304           ;;
6305         *.la)
6306           func_resolve_sysroot "$deplib"
6307           lib=$func_resolve_sysroot_result
6308           ;;
6309         *.$libext)
6310           if test "$pass" = conv; then
6311             deplibs="$deplib $deplibs"
6312             continue
6313           fi
6314           case $linkmode in
6315           lib)
6316             # Linking convenience modules into shared libraries is allowed,
6317             # but linking other static libraries is non-portable.
6318             case " $dlpreconveniencelibs " in
6319             *" $deplib "*) ;;
6320             *)
6321               valid_a_lib=no
6322               case $deplibs_check_method in
6323                 match_pattern*)
6324                   set dummy $deplibs_check_method; shift
6325                   match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6326                   if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
6327                     | $EGREP "$match_pattern_regex" > /dev/null; then
6328                     valid_a_lib=yes
6329                   fi
6330                 ;;
6331                 pass_all)
6332                   valid_a_lib=yes
6333                 ;;
6334               esac
6335               if test "$valid_a_lib" != yes; then
6336                 echo
6337                 $ECHO "*** Warning: Trying to link with static lib archive $deplib."
6338                 echo "*** I have the capability to make that library automatically link in when"
6339                 echo "*** you link to this library.  But I can only do this if you have a"
6340                 echo "*** shared version of the library, which you do not appear to have"
6341                 echo "*** because the file extensions .$libext of this argument makes me believe"
6342                 echo "*** that it is just a static archive that I should not use here."
6343               else
6344                 echo
6345                 $ECHO "*** Warning: Linking the shared library $output against the"
6346                 $ECHO "*** static library $deplib is not portable!"
6347                 deplibs="$deplib $deplibs"
6348               fi
6349               ;;
6350             esac
6351             continue
6352             ;;
6353           prog)
6354             if test "$pass" != link; then
6355               deplibs="$deplib $deplibs"
6356             else
6357               compile_deplibs="$deplib $compile_deplibs"
6358               finalize_deplibs="$deplib $finalize_deplibs"
6359             fi
6360             continue
6361             ;;
6362           esac # linkmode
6363           ;; # *.$libext
6364         *.lo | *.$objext)
6365           if test "$pass" = conv; then
6366             deplibs="$deplib $deplibs"
6367           elif test "$linkmode" = prog; then
6368             if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
6369               # If there is no dlopen support or we're linking statically,
6370               # we need to preload.
6371               func_append newdlprefiles " $deplib"
6372               compile_deplibs="$deplib $compile_deplibs"
6373               finalize_deplibs="$deplib $finalize_deplibs"
6374             else
6375               func_append newdlfiles " $deplib"
6376             fi
6377           fi
6378           continue
6379           ;;
6380         %DEPLIBS%)
6381           alldeplibs=yes
6382           continue
6383           ;;
6384         esac # case $deplib
6385
6386         if test "$found" = yes || test -f "$lib"; then :
6387         else
6388           func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
6389         fi
6390
6391         # Check to see that this really is a libtool archive.
6392         func_lalib_unsafe_p "$lib" \
6393           || func_fatal_error "\`$lib' is not a valid libtool archive"
6394
6395         func_dirname "$lib" "" "."
6396         ladir="$func_dirname_result"
6397
6398         dlname=
6399         dlopen=
6400         dlpreopen=
6401         libdir=
6402         library_names=
6403         old_library=
6404         inherited_linker_flags=
6405         # If the library was installed with an old release of libtool,
6406         # it will not redefine variables installed, or shouldnotlink
6407         installed=yes
6408         shouldnotlink=no
6409         avoidtemprpath=
6410
6411
6412         # Read the .la file
6413         func_source "$lib"
6414
6415         # Convert "-framework foo" to "foo.ltframework"
6416         if test -n "$inherited_linker_flags"; then
6417           tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
6418           for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
6419             case " $new_inherited_linker_flags " in
6420               *" $tmp_inherited_linker_flag "*) ;;
6421               *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
6422             esac
6423           done
6424         fi
6425         dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6426         if test "$linkmode,$pass" = "lib,link" ||
6427            test "$linkmode,$pass" = "prog,scan" ||
6428            { test "$linkmode" != prog && test "$linkmode" != lib; }; then
6429           test -n "$dlopen" && func_append dlfiles " $dlopen"
6430           test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
6431         fi
6432
6433         if test "$pass" = conv; then
6434           # Only check for convenience libraries
6435           deplibs="$lib $deplibs"
6436           if test -z "$libdir"; then
6437             if test -z "$old_library"; then
6438               func_fatal_error "cannot find name of link library for \`$lib'"
6439             fi
6440             # It is a libtool convenience library, so add in its objects.
6441             func_append convenience " $ladir/$objdir/$old_library"
6442             func_append old_convenience " $ladir/$objdir/$old_library"
6443           elif test "$linkmode" != prog && test "$linkmode" != lib; then
6444             func_fatal_error "\`$lib' is not a convenience library"
6445           fi
6446           tmp_libs=
6447           for deplib in $dependency_libs; do
6448             deplibs="$deplib $deplibs"
6449             if $opt_preserve_dup_deps ; then
6450               case "$tmp_libs " in
6451               *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6452               esac
6453             fi
6454             func_append tmp_libs " $deplib"
6455           done
6456           continue
6457         fi # $pass = conv
6458
6459
6460         # Get the name of the library we link against.
6461         linklib=
6462         if test -n "$old_library" &&
6463            { test "$prefer_static_libs" = yes ||
6464              test "$prefer_static_libs,$installed" = "built,no"; }; then
6465           linklib=$old_library
6466         else
6467           for l in $old_library $library_names; do
6468             linklib="$l"
6469           done
6470         fi
6471         if test -z "$linklib"; then
6472           func_fatal_error "cannot find name of link library for \`$lib'"
6473         fi
6474
6475         # This library was specified with -dlopen.
6476         if test "$pass" = dlopen; then
6477           if test -z "$libdir"; then
6478             func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
6479           fi
6480           if test -z "$dlname" ||
6481              test "$dlopen_support" != yes ||
6482              test "$build_libtool_libs" = no; then
6483             # If there is no dlname, no dlopen support or we're linking
6484             # statically, we need to preload.  We also need to preload any
6485             # dependent libraries so libltdl's deplib preloader doesn't
6486             # bomb out in the load deplibs phase.
6487             func_append dlprefiles " $lib $dependency_libs"
6488           else
6489             func_append newdlfiles " $lib"
6490           fi
6491           continue
6492         fi # $pass = dlopen
6493
6494         # We need an absolute path.
6495         case $ladir in
6496         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
6497         *)
6498           abs_ladir=`cd "$ladir" && pwd`
6499           if test -z "$abs_ladir"; then
6500             func_warning "cannot determine absolute directory name of \`$ladir'"
6501             func_warning "passing it literally to the linker, although it might fail"
6502             abs_ladir="$ladir"
6503           fi
6504           ;;
6505         esac
6506         func_basename "$lib"
6507         laname="$func_basename_result"
6508
6509         # Find the relevant object directory and library name.
6510         if test "X$installed" = Xyes; then
6511           if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6512             func_warning "library \`$lib' was moved."
6513             dir="$ladir"
6514             absdir="$abs_ladir"
6515             libdir="$abs_ladir"
6516           else
6517             # Adding 'libdir' from the .la file to our library search paths
6518             # breaks crosscompilation horribly.  We cheat here and don't add
6519             # it, instead adding the path where we found the .la.  -CL
6520             dir="$lt_sysroot$abs_ladir"
6521             absdir="$abs_ladir"
6522             libdir="$abs_ladir"
6523             #dir="$libdir"
6524             #absdir="$lt_sysroot$libdir"
6525           fi
6526           test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
6527         else
6528           if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6529             dir="$ladir"
6530             absdir="$abs_ladir"
6531             # Remove this search path later
6532             func_append notinst_path " $abs_ladir"
6533           else
6534             dir="$ladir/$objdir"
6535             absdir="$abs_ladir/$objdir"
6536             # Remove this search path later
6537             func_append notinst_path " $abs_ladir"
6538           fi
6539         fi # $installed = yes
6540         func_stripname 'lib' '.la' "$laname"
6541         name=$func_stripname_result
6542
6543         # This library was specified with -dlpreopen.
6544         if test "$pass" = dlpreopen; then
6545           if test -z "$libdir" && test "$linkmode" = prog; then
6546             func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
6547           fi
6548           case "$host" in
6549             # special handling for platforms with PE-DLLs.
6550             *cygwin* | *mingw* | *cegcc* )
6551               # Linker will automatically link against shared library if both
6552               # static and shared are present.  Therefore, ensure we extract
6553               # symbols from the import library if a shared library is present
6554               # (otherwise, the dlopen module name will be incorrect).  We do
6555               # this by putting the import library name into $newdlprefiles.
6556               # We recover the dlopen module name by 'saving' the la file
6557               # name in a special purpose variable, and (later) extracting the
6558               # dlname from the la file.
6559               if test -n "$dlname"; then
6560                 func_tr_sh "$dir/$linklib"
6561                 eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
6562                 func_append newdlprefiles " $dir/$linklib"
6563               else
6564                 func_append newdlprefiles " $dir/$old_library"
6565                 # Keep a list of preopened convenience libraries to check
6566                 # that they are being used correctly in the link pass.
6567                 test -z "$libdir" && \
6568                   func_append dlpreconveniencelibs " $dir/$old_library"
6569               fi
6570             ;;
6571             * )
6572               # Prefer using a static library (so that no silly _DYNAMIC symbols
6573               # are required to link).
6574               if test -n "$old_library"; then
6575                 func_append newdlprefiles " $dir/$old_library"
6576                 # Keep a list of preopened convenience libraries to check
6577                 # that they are being used correctly in the link pass.
6578                 test -z "$libdir" && \
6579                   func_append dlpreconveniencelibs " $dir/$old_library"
6580               # Otherwise, use the dlname, so that lt_dlopen finds it.
6581               elif test -n "$dlname"; then
6582                 func_append newdlprefiles " $dir/$dlname"
6583               else
6584                 func_append newdlprefiles " $dir/$linklib"
6585               fi
6586             ;;
6587           esac
6588         fi # $pass = dlpreopen
6589
6590         if test -z "$libdir"; then
6591           # Link the convenience library
6592           if test "$linkmode" = lib; then
6593             deplibs="$dir/$old_library $deplibs"
6594           elif test "$linkmode,$pass" = "prog,link"; then
6595             compile_deplibs="$dir/$old_library $compile_deplibs"
6596             finalize_deplibs="$dir/$old_library $finalize_deplibs"
6597           else
6598             deplibs="$lib $deplibs" # used for prog,scan pass
6599           fi
6600           continue
6601         fi
6602
6603
6604         if test "$linkmode" = prog && test "$pass" != link; then
6605           func_append newlib_search_path " $ladir"
6606           deplibs="$lib $deplibs"
6607
6608           linkalldeplibs=no
6609           if test "$link_all_deplibs" != no || test -z "$library_names" ||
6610              test "$build_libtool_libs" = no; then
6611             linkalldeplibs=yes
6612           fi
6613
6614           tmp_libs=
6615           for deplib in $dependency_libs; do
6616             case $deplib in
6617             -L*) func_stripname '-L' '' "$deplib"
6618                  func_resolve_sysroot "$func_stripname_result"
6619                  func_append newlib_search_path " $func_resolve_sysroot_result"
6620                  ;;
6621             esac
6622             # Need to link against all dependency_libs?
6623             if test "$linkalldeplibs" = yes; then
6624               deplibs="$deplib $deplibs"
6625             else
6626               # Need to hardcode shared library paths
6627               # or/and link against static libraries
6628               newdependency_libs="$deplib $newdependency_libs"
6629             fi
6630             if $opt_preserve_dup_deps ; then
6631               case "$tmp_libs " in
6632               *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6633               esac
6634             fi
6635             func_append tmp_libs " $deplib"
6636           done # for deplib
6637           continue
6638         fi # $linkmode = prog...
6639
6640         if test "$linkmode,$pass" = "prog,link"; then
6641           if test -n "$library_names" &&
6642              { { test "$prefer_static_libs" = no ||
6643                  test "$prefer_static_libs,$installed" = "built,yes"; } ||
6644                test -z "$old_library"; }; then
6645             # We need to hardcode the library path
6646             if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
6647               # Make sure the rpath contains only unique directories.
6648               case "$temp_rpath:" in
6649               *"$absdir:"*) ;;
6650               *) func_append temp_rpath "$absdir:" ;;
6651               esac
6652             fi
6653
6654             # Hardcode the library path.
6655             # Skip directories that are in the system default run-time
6656             # search path.
6657             case " $sys_lib_dlsearch_path " in
6658             *" $absdir "*) ;;
6659             *)
6660               case "$compile_rpath " in
6661               *" $absdir "*) ;;
6662               *) func_append compile_rpath " $absdir" ;;
6663               esac
6664               ;;
6665             esac
6666             case " $sys_lib_dlsearch_path " in
6667             *" $libdir "*) ;;
6668             *)
6669               case "$finalize_rpath " in
6670               *" $libdir "*) ;;
6671               *) func_append finalize_rpath " $libdir" ;;
6672               esac
6673               ;;
6674             esac
6675           fi # $linkmode,$pass = prog,link...
6676
6677           if test "$alldeplibs" = yes &&
6678              { test "$deplibs_check_method" = pass_all ||
6679                { test "$build_libtool_libs" = yes &&
6680                  test -n "$library_names"; }; }; then
6681             # We only need to search for static libraries
6682             continue
6683           fi
6684         fi
6685
6686         link_static=no # Whether the deplib will be linked statically
6687         use_static_libs=$prefer_static_libs
6688         if test "$use_static_libs" = built && test "$installed" = yes; then
6689           use_static_libs=no
6690         fi
6691         if test -n "$library_names" &&
6692            { test "$use_static_libs" = no || test -z "$old_library"; }; then
6693           case $host in
6694           *cygwin* | *mingw* | *cegcc*)
6695               # No point in relinking DLLs because paths are not encoded
6696               func_append notinst_deplibs " $lib"
6697               need_relink=no
6698             ;;
6699           *)
6700             if test "$installed" = no; then
6701               func_append notinst_deplibs " $lib"
6702               need_relink=yes
6703             fi
6704             ;;
6705           esac
6706           # This is a shared library
6707
6708           # Warn about portability, can't link against -module's on some
6709           # systems (darwin).  Don't bleat about dlopened modules though!
6710           dlopenmodule=""
6711           for dlpremoduletest in $dlprefiles; do
6712             if test "X$dlpremoduletest" = "X$lib"; then
6713               dlopenmodule="$dlpremoduletest"
6714               break
6715             fi
6716           done
6717           if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
6718             echo
6719             if test "$linkmode" = prog; then
6720               $ECHO "*** Warning: Linking the executable $output against the loadable module"
6721             else
6722               $ECHO "*** Warning: Linking the shared library $output against the loadable module"
6723             fi
6724             $ECHO "*** $linklib is not portable!"
6725           fi
6726           if test "$linkmode" = lib &&
6727              test "$hardcode_into_libs" = yes; then
6728             # Hardcode the library path.
6729             # Skip directories that are in the system default run-time
6730             # search path.
6731             case " $sys_lib_dlsearch_path " in
6732             *" $absdir "*) ;;
6733             *)
6734               case "$compile_rpath " in
6735               *" $absdir "*) ;;
6736               *) func_append compile_rpath " $absdir" ;;
6737               esac
6738               ;;
6739             esac
6740             case " $sys_lib_dlsearch_path " in
6741             *" $libdir "*) ;;
6742             *)
6743               case "$finalize_rpath " in
6744               *" $libdir "*) ;;
6745               *) func_append finalize_rpath " $libdir" ;;
6746               esac
6747               ;;
6748             esac
6749           fi
6750
6751           if test -n "$old_archive_from_expsyms_cmds"; then
6752             # figure out the soname
6753             set dummy $library_names
6754             shift
6755             realname="$1"
6756             shift
6757             libname=`eval "\\$ECHO \"$libname_spec\""`
6758             # use dlname if we got it. it's perfectly good, no?
6759             if test -n "$dlname"; then
6760               soname="$dlname"
6761             elif test -n "$soname_spec"; then
6762               # bleh windows
6763               case $host in
6764               *cygwin* | mingw* | *cegcc*)
6765                 func_arith $current - $age
6766                 major=$func_arith_result
6767                 versuffix="-$major"
6768                 ;;
6769               esac
6770               eval soname=\"$soname_spec\"
6771             else
6772               soname="$realname"
6773             fi
6774
6775             # Make a new name for the extract_expsyms_cmds to use
6776             soroot="$soname"
6777             func_basename "$soroot"
6778             soname="$func_basename_result"
6779             func_stripname 'lib' '.dll' "$soname"
6780             newlib=libimp-$func_stripname_result.a
6781
6782             # If the library has no export list, then create one now
6783             if test -f "$output_objdir/$soname-def"; then :
6784             else
6785               func_verbose "extracting exported symbol list from \`$soname'"
6786               func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
6787             fi
6788
6789             # Create $newlib
6790             if test -f "$output_objdir/$newlib"; then :; else
6791               func_verbose "generating import library for \`$soname'"
6792               func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
6793             fi
6794             # make sure the library variables are pointing to the new library
6795             dir=$output_objdir
6796             linklib=$newlib
6797           fi # test -n "$old_archive_from_expsyms_cmds"
6798
6799           if test "$linkmode" = prog || test "$opt_mode" != relink; then
6800             add_shlibpath=
6801             add_dir=
6802             add=
6803             lib_linked=yes
6804             case $hardcode_action in
6805             immediate | unsupported)
6806               if test "$hardcode_direct" = no; then
6807                 add="$dir/$linklib"
6808                 case $host in
6809                   *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
6810                   *-*-sysv4*uw2*) add_dir="-L$dir" ;;
6811                   *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
6812                     *-*-unixware7*) add_dir="-L$dir" ;;
6813                   *-*-darwin* )
6814                     # if the lib is a (non-dlopened) module then we can not
6815                     # link against it, someone is ignoring the earlier warnings
6816                     if /usr/bin/file -L $add 2> /dev/null |
6817                          $GREP ": [^:]* bundle" >/dev/null ; then
6818                       if test "X$dlopenmodule" != "X$lib"; then
6819                         $ECHO "*** Warning: lib $linklib is a module, not a shared library"
6820                         if test -z "$old_library" ; then
6821                           echo
6822                           echo "*** And there doesn't seem to be a static archive available"
6823                           echo "*** The link will probably fail, sorry"
6824                         else
6825                           add="$dir/$old_library"
6826                         fi
6827                       elif test -n "$old_library"; then
6828                         add="$dir/$old_library"
6829                       fi
6830                     fi
6831                 esac
6832               elif test "$hardcode_minus_L" = no; then
6833                 case $host in
6834                 *-*-sunos*) add_shlibpath="$dir" ;;
6835                 esac
6836                 add_dir="-L$dir"
6837                 add="-l$name"
6838               elif test "$hardcode_shlibpath_var" = no; then
6839                 add_shlibpath="$dir"
6840                 add="-l$name"
6841               else
6842                 lib_linked=no
6843               fi
6844               ;;
6845             relink)
6846               if test "$hardcode_direct" = yes &&
6847                  test "$hardcode_direct_absolute" = no; then
6848                 add="$dir/$linklib"
6849               elif test "$hardcode_minus_L" = yes; then
6850                 add_dir="-L$dir"
6851                 # Try looking first in the location we're being installed to.
6852                 if test -n "$inst_prefix_dir"; then
6853                   case $libdir in
6854                     [\\/]*)
6855                       func_append add_dir " -L$inst_prefix_dir$libdir"
6856                       ;;
6857                   esac
6858                 fi
6859                 add="-l$name"
6860               elif test "$hardcode_shlibpath_var" = yes; then
6861                 add_shlibpath="$dir"
6862                 add="-l$name"
6863               else
6864                 lib_linked=no
6865               fi
6866               ;;
6867             *) lib_linked=no ;;
6868             esac
6869
6870             if test "$lib_linked" != yes; then
6871               func_fatal_configuration "unsupported hardcode properties"
6872             fi
6873
6874             if test -n "$add_shlibpath"; then
6875               case :$compile_shlibpath: in
6876               *":$add_shlibpath:"*) ;;
6877               *) func_append compile_shlibpath "$add_shlibpath:" ;;
6878               esac
6879             fi
6880             if test "$linkmode" = prog; then
6881               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
6882               test -n "$add" && compile_deplibs="$add $compile_deplibs"
6883             else
6884               test -n "$add_dir" && deplibs="$add_dir $deplibs"
6885               test -n "$add" && deplibs="$add $deplibs"
6886               if test "$hardcode_direct" != yes &&
6887                  test "$hardcode_minus_L" != yes &&
6888                  test "$hardcode_shlibpath_var" = yes; then
6889                 case :$finalize_shlibpath: in
6890                 *":$libdir:"*) ;;
6891                 *) func_append finalize_shlibpath "$libdir:" ;;
6892                 esac
6893               fi
6894             fi
6895           fi
6896
6897           if test "$linkmode" = prog || test "$opt_mode" = relink; then
6898             add_shlibpath=
6899             add_dir=
6900             add=
6901             # Finalize command for both is simple: just hardcode it.
6902             if test "$hardcode_direct" = yes &&
6903                test "$hardcode_direct_absolute" = no; then
6904               add="$libdir/$linklib"
6905             elif test "$hardcode_minus_L" = yes; then
6906               add="-l$name"
6907             elif test "$hardcode_shlibpath_var" = yes; then
6908               case :$finalize_shlibpath: in
6909               *":$libdir:"*) ;;
6910               *) func_append finalize_shlibpath "$libdir:" ;;
6911               esac
6912               add="-l$name"
6913             elif test "$hardcode_automatic" = yes; then
6914               if test -n "$inst_prefix_dir" &&
6915                  test -f "$inst_prefix_dir$libdir/$linklib" ; then
6916                 add="$inst_prefix_dir$libdir/$linklib"
6917               else
6918                 add="$libdir/$linklib"
6919               fi
6920             else
6921               # Try looking first in the location we're being installed to.
6922               if test -n "$inst_prefix_dir"; then
6923                 case $libdir in
6924                   [\\/]*)
6925                     func_append add_dir " -L$inst_prefix_dir$libdir"
6926                     ;;
6927                 esac
6928               fi
6929               add="-l$name"
6930             fi
6931
6932             if test "$linkmode" = prog; then
6933               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6934               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6935             else
6936               test -n "$add_dir" && deplibs="$add_dir $deplibs"
6937               test -n "$add" && deplibs="$add $deplibs"
6938             fi
6939           fi
6940         elif test "$linkmode" = prog; then
6941           # Here we assume that one of hardcode_direct or hardcode_minus_L
6942           # is not unsupported.  This is valid on all known static and
6943           # shared platforms.
6944           if test "$hardcode_direct" != unsupported; then
6945             test -n "$old_library" && linklib="$old_library"
6946             compile_deplibs="$dir/$linklib $compile_deplibs"
6947             finalize_deplibs="$dir/$linklib $finalize_deplibs"
6948           else
6949             compile_deplibs="-l$name -L$dir $compile_deplibs"
6950             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6951           fi
6952         elif test "$build_libtool_libs" = yes; then
6953           # Not a shared library
6954           if test "$deplibs_check_method" != pass_all; then
6955             # We're trying link a shared library against a static one
6956             # but the system doesn't support it.
6957
6958             # Just print a warning and add the library to dependency_libs so
6959             # that the program can be linked against the static library.
6960             echo
6961             $ECHO "*** Warning: This system can not link to static lib archive $lib."
6962             echo "*** I have the capability to make that library automatically link in when"
6963             echo "*** you link to this library.  But I can only do this if you have a"
6964             echo "*** shared version of the library, which you do not appear to have."
6965             if test "$module" = yes; then
6966               echo "*** But as you try to build a module library, libtool will still create "
6967               echo "*** a static module, that should work as long as the dlopening application"
6968               echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
6969               if test -z "$global_symbol_pipe"; then
6970                 echo
6971                 echo "*** However, this would only work if libtool was able to extract symbol"
6972                 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6973                 echo "*** not find such a program.  So, this module is probably useless."
6974                 echo "*** \`nm' from GNU binutils and a full rebuild may help."
6975               fi
6976               if test "$build_old_libs" = no; then
6977                 build_libtool_libs=module
6978                 build_old_libs=yes
6979               else
6980                 build_libtool_libs=no
6981               fi
6982             fi
6983           else
6984             deplibs="$dir/$old_library $deplibs"
6985             link_static=yes
6986           fi
6987         fi # link shared/static library?
6988
6989         if test "$linkmode" = lib; then
6990           if test -n "$dependency_libs" &&
6991              { test "$hardcode_into_libs" != yes ||
6992                test "$build_old_libs" = yes ||
6993                test "$link_static" = yes; }; then
6994             # Extract -R from dependency_libs
6995             temp_deplibs=
6996             for libdir in $dependency_libs; do
6997               case $libdir in
6998               -R*) func_stripname '-R' '' "$libdir"
6999                    temp_xrpath=$func_stripname_result
7000                    case " $xrpath " in
7001                    *" $temp_xrpath "*) ;;
7002                    *) func_append xrpath " $temp_xrpath";;
7003                    esac;;
7004               *) func_append temp_deplibs " $libdir";;
7005               esac
7006             done
7007             dependency_libs="$temp_deplibs"
7008           fi
7009
7010           func_append newlib_search_path " $absdir"
7011           # Link against this library
7012           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
7013           # ... and its dependency_libs
7014           tmp_libs=
7015           for deplib in $dependency_libs; do
7016             newdependency_libs="$deplib $newdependency_libs"
7017             case $deplib in
7018               -L*) func_stripname '-L' '' "$deplib"
7019                    func_resolve_sysroot "$func_stripname_result";;
7020               *) func_resolve_sysroot "$deplib" ;;
7021             esac
7022             if $opt_preserve_dup_deps ; then
7023               case "$tmp_libs " in
7024               *" $func_resolve_sysroot_result "*)
7025                 func_append specialdeplibs " $func_resolve_sysroot_result" ;;
7026               esac
7027             fi
7028             func_append tmp_libs " $func_resolve_sysroot_result"
7029           done
7030
7031           if test "$link_all_deplibs" != no; then
7032             # Add the search paths of all dependency libraries
7033             for deplib in $dependency_libs; do
7034               path=
7035               case $deplib in
7036               -L*) path="$deplib" ;;
7037               *.la)
7038                 func_resolve_sysroot "$deplib"
7039                 deplib=$func_resolve_sysroot_result
7040                 func_dirname "$deplib" "" "."
7041                 dir=$func_dirname_result
7042                 # We need an absolute path.
7043                 case $dir in
7044                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
7045                 *)
7046                   absdir=`cd "$dir" && pwd`
7047                   if test -z "$absdir"; then
7048                     func_warning "cannot determine absolute directory name of \`$dir'"
7049                     absdir="$dir"
7050                   fi
7051                   ;;
7052                 esac
7053                 if $GREP "^installed=no" $deplib > /dev/null; then
7054                 case $host in
7055                 *-*-darwin*)
7056                   depdepl=
7057                   eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
7058                   if test -n "$deplibrary_names" ; then
7059                     for tmp in $deplibrary_names ; do
7060                       depdepl=$tmp
7061                     done
7062                     if test -f "$absdir/$objdir/$depdepl" ; then
7063                       depdepl="$absdir/$objdir/$depdepl"
7064                       darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7065                       if test -z "$darwin_install_name"; then
7066                           darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
7067                       fi
7068                       func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
7069                       func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
7070                       path=
7071                     fi
7072                   fi
7073                   ;;
7074                 *)
7075                   # OE sets installed=no in staging. We need to look in $objdir and $absdir,
7076                   # preferring $objdir. RP 31/04/2008
7077                   if test -f "$absdir/$objdir/$depdepl" ; then
7078                     depdepl="$absdir/$objdir/$depdepl"
7079                     path="-L$absdir/$objdir"
7080                   elif test -f "$absdir/$depdepl" ; then
7081                     depdepl="$absdir/$depdepl"
7082                     path="-L$absdir"
7083                   else
7084                     path="-L$absdir/$objdir"
7085                   fi
7086                   ;;
7087                 esac
7088                 else
7089                   eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
7090                   test -z "$libdir" && \
7091                     func_fatal_error "\`$deplib' is not a valid libtool archive"
7092                   test "$absdir" != "$libdir" && \
7093                     func_warning "\`$deplib' seems to be moved"
7094
7095                   path="-L$absdir"
7096                 fi
7097                 ;;
7098               esac
7099               case " $deplibs " in
7100               *" $path "*) ;;
7101               *) deplibs="$path $deplibs" ;;
7102               esac
7103             done
7104           fi # link_all_deplibs != no
7105         fi # linkmode = lib
7106       done # for deplib in $libs
7107       if test "$pass" = link; then
7108         if test "$linkmode" = "prog"; then
7109           compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
7110           finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
7111         else
7112           compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7113         fi
7114       fi
7115       dependency_libs="$newdependency_libs"
7116       if test "$pass" = dlpreopen; then
7117         # Link the dlpreopened libraries before other libraries
7118         for deplib in $save_deplibs; do
7119           deplibs="$deplib $deplibs"
7120         done
7121       fi
7122       if test "$pass" != dlopen; then
7123         if test "$pass" != conv; then
7124           # Make sure lib_search_path contains only unique directories.
7125           lib_search_path=
7126           for dir in $newlib_search_path; do
7127             case "$lib_search_path " in
7128             *" $dir "*) ;;
7129             *) func_append lib_search_path " $dir" ;;
7130             esac
7131           done
7132           newlib_search_path=
7133         fi
7134
7135         if test "$linkmode,$pass" != "prog,link"; then
7136           vars="deplibs"
7137         else
7138           vars="compile_deplibs finalize_deplibs"
7139         fi
7140         for var in $vars dependency_libs; do
7141           # Add libraries to $var in reverse order
7142           eval tmp_libs=\"\$$var\"
7143           new_libs=
7144           for deplib in $tmp_libs; do
7145             # FIXME: Pedantically, this is the right thing to do, so
7146             #        that some nasty dependency loop isn't accidentally
7147             #        broken:
7148             #new_libs="$deplib $new_libs"
7149             # Pragmatically, this seems to cause very few problems in
7150             # practice:
7151             case $deplib in
7152             -L*) new_libs="$deplib $new_libs" ;;
7153             -R*) ;;
7154             *)
7155               # And here is the reason: when a library appears more
7156               # than once as an explicit dependence of a library, or
7157               # is implicitly linked in more than once by the
7158               # compiler, it is considered special, and multiple
7159               # occurrences thereof are not removed.  Compare this
7160               # with having the same library being listed as a
7161               # dependency of multiple other libraries: in this case,
7162               # we know (pedantically, we assume) the library does not
7163               # need to be listed more than once, so we keep only the
7164               # last copy.  This is not always right, but it is rare
7165               # enough that we require users that really mean to play
7166               # such unportable linking tricks to link the library
7167               # using -Wl,-lname, so that libtool does not consider it
7168               # for duplicate removal.
7169               case " $specialdeplibs " in
7170               *" $deplib "*) new_libs="$deplib $new_libs" ;;
7171               *)
7172                 case " $new_libs " in
7173                 *" $deplib "*) ;;
7174                 *) new_libs="$deplib $new_libs" ;;
7175                 esac
7176                 ;;
7177               esac
7178               ;;
7179             esac
7180           done
7181           tmp_libs=
7182           for deplib in $new_libs; do
7183             case $deplib in
7184             -L*)
7185               case " $tmp_libs " in
7186               *" $deplib "*) ;;
7187               *) func_append tmp_libs " $deplib" ;;
7188               esac
7189               ;;
7190             *) func_append tmp_libs " $deplib" ;;
7191             esac
7192           done
7193           eval $var=\"$tmp_libs\"
7194         done # for var
7195       fi
7196       # Last step: remove runtime libs from dependency_libs
7197       # (they stay in deplibs)
7198       tmp_libs=
7199       for i in $dependency_libs ; do
7200         case " $predeps $postdeps $compiler_lib_search_path " in
7201         *" $i "*)
7202           i=""
7203           ;;
7204         esac
7205         if test -n "$i" ; then
7206           func_append tmp_libs " $i"
7207         fi
7208       done
7209       dependency_libs=$tmp_libs
7210     done # for pass
7211     if test "$linkmode" = prog; then
7212       dlfiles="$newdlfiles"
7213     fi
7214     if test "$linkmode" = prog || test "$linkmode" = lib; then
7215       dlprefiles="$newdlprefiles"
7216     fi
7217
7218     case $linkmode in
7219     oldlib)
7220       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7221         func_warning "\`-dlopen' is ignored for archives"
7222       fi
7223
7224       case " $deplibs" in
7225       *\ -l* | *\ -L*)
7226         func_warning "\`-l' and \`-L' are ignored for archives" ;;
7227       esac
7228
7229       test -n "$rpath" && \
7230         func_warning "\`-rpath' is ignored for archives"
7231
7232       test -n "$xrpath" && \
7233         func_warning "\`-R' is ignored for archives"
7234
7235       test -n "$vinfo" && \
7236         func_warning "\`-version-info/-version-number' is ignored for archives"
7237
7238       test -n "$release" && \
7239         func_warning "\`-release' is ignored for archives"
7240
7241       test -n "$export_symbols$export_symbols_regex" && \
7242         func_warning "\`-export-symbols' is ignored for archives"
7243
7244       # Now set the variables for building old libraries.
7245       build_libtool_libs=no
7246       oldlibs="$output"
7247       func_append objs "$old_deplibs"
7248       ;;
7249
7250     lib)
7251       # Make sure we only generate libraries of the form `libNAME.la'.
7252       case $outputname in
7253       lib*)
7254         func_stripname 'lib' '.la' "$outputname"
7255         name=$func_stripname_result
7256         eval shared_ext=\"$shrext_cmds\"
7257         eval libname=\"$libname_spec\"
7258         ;;
7259       *)
7260         test "$module" = no && \
7261           func_fatal_help "libtool library \`$output' must begin with \`lib'"
7262
7263         if test "$need_lib_prefix" != no; then
7264           # Add the "lib" prefix for modules if required
7265           func_stripname '' '.la' "$outputname"
7266           name=$func_stripname_result
7267           eval shared_ext=\"$shrext_cmds\"
7268           eval libname=\"$libname_spec\"
7269         else
7270           func_stripname '' '.la' "$outputname"
7271           libname=$func_stripname_result
7272         fi
7273         ;;
7274       esac
7275
7276       if test -n "$objs"; then
7277         if test "$deplibs_check_method" != pass_all; then
7278           func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
7279         else
7280           echo
7281           $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
7282           $ECHO "*** objects $objs is not portable!"
7283           func_append libobjs " $objs"
7284         fi
7285       fi
7286
7287       test "$dlself" != no && \
7288         func_warning "\`-dlopen self' is ignored for libtool libraries"
7289
7290       set dummy $rpath
7291       shift
7292       test "$#" -gt 1 && \
7293         func_warning "ignoring multiple \`-rpath's for a libtool library"
7294
7295       install_libdir="$1"
7296
7297       oldlibs=
7298       if test -z "$rpath"; then
7299         if test "$build_libtool_libs" = yes; then
7300           # Building a libtool convenience library.
7301           # Some compilers have problems with a `.al' extension so
7302           # convenience libraries should have the same extension an
7303           # archive normally would.
7304           oldlibs="$output_objdir/$libname.$libext $oldlibs"
7305           build_libtool_libs=convenience
7306           build_old_libs=yes
7307         fi
7308
7309         test -n "$vinfo" && \
7310           func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
7311
7312         test -n "$release" && \
7313           func_warning "\`-release' is ignored for convenience libraries"
7314       else
7315
7316         # Parse the version information argument.
7317         save_ifs="$IFS"; IFS=':'
7318         set dummy $vinfo 0 0 0
7319         shift
7320         IFS="$save_ifs"
7321
7322         test -n "$7" && \
7323           func_fatal_help "too many parameters to \`-version-info'"
7324
7325         # convert absolute version numbers to libtool ages
7326         # this retains compatibility with .la files and attempts
7327         # to make the code below a bit more comprehensible
7328
7329         case $vinfo_number in
7330         yes)
7331           number_major="$1"
7332           number_minor="$2"
7333           number_revision="$3"
7334           #
7335           # There are really only two kinds -- those that
7336           # use the current revision as the major version
7337           # and those that subtract age and use age as
7338           # a minor version.  But, then there is irix
7339           # which has an extra 1 added just for fun
7340           #
7341           case $version_type in
7342           darwin|linux|osf|windows|none)
7343             func_arith $number_major + $number_minor
7344             current=$func_arith_result
7345             age="$number_minor"
7346             revision="$number_revision"
7347             ;;
7348           freebsd-aout|freebsd-elf|qnx|sunos)
7349             current="$number_major"
7350             revision="$number_minor"
7351             age="0"
7352             ;;
7353           irix|nonstopux)
7354             func_arith $number_major + $number_minor
7355             current=$func_arith_result
7356             age="$number_minor"
7357             revision="$number_minor"
7358             lt_irix_increment=no
7359             ;;
7360           esac
7361           ;;
7362         no)
7363           current="$1"
7364           revision="$2"
7365           age="$3"
7366           ;;
7367         esac
7368
7369         # Check that each of the things are valid numbers.
7370         case $current in
7371         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]) ;;
7372         *)
7373           func_error "CURRENT \`$current' must be a nonnegative integer"
7374           func_fatal_error "\`$vinfo' is not valid version information"
7375           ;;
7376         esac
7377
7378         case $revision in
7379         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]) ;;
7380         *)
7381           func_error "REVISION \`$revision' must be a nonnegative integer"
7382           func_fatal_error "\`$vinfo' is not valid version information"
7383           ;;
7384         esac
7385
7386         case $age in
7387         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]) ;;
7388         *)
7389           func_error "AGE \`$age' must be a nonnegative integer"
7390           func_fatal_error "\`$vinfo' is not valid version information"
7391           ;;
7392         esac
7393
7394         if test "$age" -gt "$current"; then
7395           func_error "AGE \`$age' is greater than the current interface number \`$current'"
7396           func_fatal_error "\`$vinfo' is not valid version information"
7397         fi
7398
7399         # Calculate the version variables.
7400         major=
7401         versuffix=
7402         verstring=
7403         case $version_type in
7404         none) ;;
7405
7406         darwin)
7407           # Like Linux, but with the current version available in
7408           # verstring for coding it into the library header
7409           func_arith $current - $age
7410           major=.$func_arith_result
7411           versuffix="$major.$age.$revision"
7412           # Darwin ld doesn't like 0 for these options...
7413           func_arith $current + 1
7414           minor_current=$func_arith_result
7415           xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
7416           verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
7417           ;;
7418
7419         freebsd-aout)
7420           major=".$current"
7421           versuffix=".$current.$revision";
7422           ;;
7423
7424         freebsd-elf)
7425           major=".$current"
7426           versuffix=".$current"
7427           ;;
7428
7429         irix | nonstopux)
7430           if test "X$lt_irix_increment" = "Xno"; then
7431             func_arith $current - $age
7432           else
7433             func_arith $current - $age + 1
7434           fi
7435           major=$func_arith_result
7436
7437           case $version_type in
7438             nonstopux) verstring_prefix=nonstopux ;;
7439             *)         verstring_prefix=sgi ;;
7440           esac
7441           verstring="$verstring_prefix$major.$revision"
7442
7443           # Add in all the interfaces that we are compatible with.
7444           loop=$revision
7445           while test "$loop" -ne 0; do
7446             func_arith $revision - $loop
7447             iface=$func_arith_result
7448             func_arith $loop - 1
7449             loop=$func_arith_result
7450             verstring="$verstring_prefix$major.$iface:$verstring"
7451           done
7452
7453           # Before this point, $major must not contain `.'.
7454           major=.$major
7455           versuffix="$major.$revision"
7456           ;;
7457
7458         linux)
7459           func_arith $current - $age
7460           major=.$func_arith_result
7461           versuffix="$major.$age.$revision"
7462           ;;
7463
7464         osf)
7465           func_arith $current - $age
7466           major=.$func_arith_result
7467           versuffix=".$current.$age.$revision"
7468           verstring="$current.$age.$revision"
7469
7470           # Add in all the interfaces that we are compatible with.
7471           loop=$age
7472           while test "$loop" -ne 0; do
7473             func_arith $current - $loop
7474             iface=$func_arith_result
7475             func_arith $loop - 1
7476             loop=$func_arith_result
7477             verstring="$verstring:${iface}.0"
7478           done
7479
7480           # Make executables depend on our current version.
7481           func_append verstring ":${current}.0"
7482           ;;
7483
7484         qnx)
7485           major=".$current"
7486           versuffix=".$current"
7487           ;;
7488
7489         sunos)
7490           major=".$current"
7491           versuffix=".$current.$revision"
7492           ;;
7493
7494         windows)
7495           # Use '-' rather than '.', since we only want one
7496           # extension on DOS 8.3 filesystems.
7497           func_arith $current - $age
7498           major=$func_arith_result
7499           versuffix="-$major"
7500           ;;
7501
7502         *)
7503           func_fatal_configuration "unknown library version type \`$version_type'"
7504           ;;
7505         esac
7506
7507         # Clear the version info if we defaulted, and they specified a release.
7508         if test -z "$vinfo" && test -n "$release"; then
7509           major=
7510           case $version_type in
7511           darwin)
7512             # we can't check for "0.0" in archive_cmds due to quoting
7513             # problems, so we reset it completely
7514             verstring=
7515             ;;
7516           *)
7517             verstring="0.0"
7518             ;;
7519           esac
7520           if test "$need_version" = no; then
7521             versuffix=
7522           else
7523             versuffix=".0.0"
7524           fi
7525         fi
7526
7527         # Remove version info from name if versioning should be avoided
7528         if test "$avoid_version" = yes && test "$need_version" = no; then
7529           major=
7530           versuffix=
7531           verstring=""
7532         fi
7533
7534         # Check to see if the archive will have undefined symbols.
7535         if test "$allow_undefined" = yes; then
7536           if test "$allow_undefined_flag" = unsupported; then
7537             func_warning "undefined symbols not allowed in $host shared libraries"
7538             build_libtool_libs=no
7539             build_old_libs=yes
7540           fi
7541         else
7542           # Don't allow undefined symbols.
7543           allow_undefined_flag="$no_undefined_flag"
7544         fi
7545
7546       fi
7547
7548       func_generate_dlsyms "$libname" "$libname" "yes"
7549       func_append libobjs " $symfileobj"
7550       test "X$libobjs" = "X " && libobjs=
7551
7552       if test "$opt_mode" != relink; then
7553         # Remove our outputs, but don't remove object files since they
7554         # may have been created when compiling PIC objects.
7555         removelist=
7556         tempremovelist=`$ECHO "$output_objdir/*"`
7557         for p in $tempremovelist; do
7558           case $p in
7559             *.$objext | *.gcno)
7560                ;;
7561             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
7562                if test "X$precious_files_regex" != "X"; then
7563                  if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
7564                  then
7565                    continue
7566                  fi
7567                fi
7568                func_append removelist " $p"
7569                ;;
7570             *) ;;
7571           esac
7572         done
7573         test -n "$removelist" && \
7574           func_show_eval "${RM}r \$removelist"
7575       fi
7576
7577       # Now set the variables for building old libraries.
7578       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
7579         func_append oldlibs " $output_objdir/$libname.$libext"
7580
7581         # Transform .lo files to .o files.
7582         oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
7583       fi
7584
7585       # Eliminate all temporary directories.
7586       #for path in $notinst_path; do
7587       # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
7588       # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
7589       # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
7590       #done
7591
7592       if test -n "$xrpath"; then
7593         # If the user specified any rpath flags, then add them.
7594         temp_xrpath=
7595         for libdir in $xrpath; do
7596           func_replace_sysroot "$libdir"
7597           func_append temp_xrpath " -R$func_replace_sysroot_result"
7598           case "$finalize_rpath " in
7599           *" $libdir "*) ;;
7600           *) func_append finalize_rpath " $libdir" ;;
7601           esac
7602         done
7603         if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
7604           dependency_libs="$temp_xrpath $dependency_libs"
7605         fi
7606       fi
7607
7608       # Make sure dlfiles contains only unique files that won't be dlpreopened
7609       old_dlfiles="$dlfiles"
7610       dlfiles=
7611       for lib in $old_dlfiles; do
7612         case " $dlprefiles $dlfiles " in
7613         *" $lib "*) ;;
7614         *) func_append dlfiles " $lib" ;;
7615         esac
7616       done
7617
7618       # Make sure dlprefiles contains only unique files
7619       old_dlprefiles="$dlprefiles"
7620       dlprefiles=
7621       for lib in $old_dlprefiles; do
7622         case "$dlprefiles " in
7623         *" $lib "*) ;;
7624         *) func_append dlprefiles " $lib" ;;
7625         esac
7626       done
7627
7628       if test "$build_libtool_libs" = yes; then
7629         if test -n "$rpath"; then
7630           case $host in
7631           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
7632             # these systems don't actually have a c library (as such)!
7633             ;;
7634           *-*-rhapsody* | *-*-darwin1.[012])
7635             # Rhapsody C library is in the System framework
7636             func_append deplibs " System.ltframework"
7637             ;;
7638           *-*-netbsd*)
7639             # Don't link with libc until the a.out ld.so is fixed.
7640             ;;
7641           *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
7642             # Do not include libc due to us having libc/libc_r.
7643             ;;
7644           *-*-sco3.2v5* | *-*-sco5v6*)
7645             # Causes problems with __ctype
7646             ;;
7647           *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
7648             # Compiler inserts libc in the correct place for threads to work
7649             ;;
7650           *)
7651             # Add libc to deplibs on all other systems if necessary.
7652             if test "$build_libtool_need_lc" = "yes"; then
7653               func_append deplibs " -lc"
7654             fi
7655             ;;
7656           esac
7657         fi
7658
7659         # Transform deplibs into only deplibs that can be linked in shared.
7660         name_save=$name
7661         libname_save=$libname
7662         release_save=$release
7663         versuffix_save=$versuffix
7664         major_save=$major
7665         # I'm not sure if I'm treating the release correctly.  I think
7666         # release should show up in the -l (ie -lgmp5) so we don't want to
7667         # add it in twice.  Is that correct?
7668         release=""
7669         versuffix=""
7670         major=""
7671         newdeplibs=
7672         droppeddeps=no
7673         case $deplibs_check_method in
7674         pass_all)
7675           # Don't check for shared/static.  Everything works.
7676           # This might be a little naive.  We might want to check
7677           # whether the library exists or not.  But this is on
7678           # osf3 & osf4 and I'm not really sure... Just
7679           # implementing what was already the behavior.
7680           newdeplibs=$deplibs
7681           ;;
7682         test_compile)
7683           # This code stresses the "libraries are programs" paradigm to its
7684           # limits. Maybe even breaks it.  We compile a program, linking it
7685           # against the deplibs as a proxy for the library.  Then we can check
7686           # whether they linked in statically or dynamically with ldd.
7687           $opt_dry_run || $RM conftest.c
7688           cat > conftest.c <<EOF
7689           int main() { return 0; }
7690 EOF
7691           $opt_dry_run || $RM conftest
7692           if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
7693             ldd_output=`ldd conftest`
7694             for i in $deplibs; do
7695               case $i in
7696               -l*)
7697                 func_stripname -l '' "$i"
7698                 name=$func_stripname_result
7699                 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7700                   case " $predeps $postdeps " in
7701                   *" $i "*)
7702                     func_append newdeplibs " $i"
7703                     i=""
7704                     ;;
7705                   esac
7706                 fi
7707                 if test -n "$i" ; then
7708                   libname=`eval "\\$ECHO \"$libname_spec\""`
7709                   deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7710                   set dummy $deplib_matches; shift
7711                   deplib_match=$1
7712                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7713                     func_append newdeplibs " $i"
7714                   else
7715                     droppeddeps=yes
7716                     echo
7717                     $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7718                     echo "*** I have the capability to make that library automatically link in when"
7719                     echo "*** you link to this library.  But I can only do this if you have a"
7720                     echo "*** shared version of the library, which I believe you do not have"
7721                     echo "*** because a test_compile did reveal that the linker did not use it for"
7722                     echo "*** its dynamic dependency list that programs get resolved with at runtime."
7723                   fi
7724                 fi
7725                 ;;
7726               *)
7727                 func_append newdeplibs " $i"
7728                 ;;
7729               esac
7730             done
7731           else
7732             # Error occurred in the first compile.  Let's try to salvage
7733             # the situation: Compile a separate program for each library.
7734             for i in $deplibs; do
7735               case $i in
7736               -l*)
7737                 func_stripname -l '' "$i"
7738                 name=$func_stripname_result
7739                 $opt_dry_run || $RM conftest
7740                 if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
7741                   ldd_output=`ldd conftest`
7742                   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7743                     case " $predeps $postdeps " in
7744                     *" $i "*)
7745                       func_append newdeplibs " $i"
7746                       i=""
7747                       ;;
7748                     esac
7749                   fi
7750                   if test -n "$i" ; then
7751                     libname=`eval "\\$ECHO \"$libname_spec\""`
7752                     deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7753                     set dummy $deplib_matches; shift
7754                     deplib_match=$1
7755                     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7756                       func_append newdeplibs " $i"
7757                     else
7758                       droppeddeps=yes
7759                       echo
7760                       $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7761                       echo "*** I have the capability to make that library automatically link in when"
7762                       echo "*** you link to this library.  But I can only do this if you have a"
7763                       echo "*** shared version of the library, which you do not appear to have"
7764                       echo "*** because a test_compile did reveal that the linker did not use this one"
7765                       echo "*** as a dynamic dependency that programs can get resolved with at runtime."
7766                     fi
7767                   fi
7768                 else
7769                   droppeddeps=yes
7770                   echo
7771                   $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
7772                   echo "*** make it link in!  You will probably need to install it or some"
7773                   echo "*** library that it depends on before this library will be fully"
7774                   echo "*** functional.  Installing it before continuing would be even better."
7775                 fi
7776                 ;;
7777               *)
7778                 func_append newdeplibs " $i"
7779                 ;;
7780               esac
7781             done
7782           fi
7783           ;;
7784         file_magic*)
7785           set dummy $deplibs_check_method; shift
7786           file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7787           for a_deplib in $deplibs; do
7788             case $a_deplib in
7789             -l*)
7790               func_stripname -l '' "$a_deplib"
7791               name=$func_stripname_result
7792               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7793                 case " $predeps $postdeps " in
7794                 *" $a_deplib "*)
7795                   func_append newdeplibs " $a_deplib"
7796                   a_deplib=""
7797                   ;;
7798                 esac
7799               fi
7800               if test -n "$a_deplib" ; then
7801                 libname=`eval "\\$ECHO \"$libname_spec\""`
7802                 if test -n "$file_magic_glob"; then
7803                   libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
7804                 else
7805                   libnameglob=$libname
7806                 fi
7807                 test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
7808                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7809                   if test "$want_nocaseglob" = yes; then
7810                     shopt -s nocaseglob
7811                     potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7812                     $nocaseglob
7813                   else
7814                     potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7815                   fi
7816                   for potent_lib in $potential_libs; do
7817                       # Follow soft links.
7818                       if ls -lLd "$potent_lib" 2>/dev/null |
7819                          $GREP " -> " >/dev/null; then
7820                         continue
7821                       fi
7822                       # The statement above tries to avoid entering an
7823                       # endless loop below, in case of cyclic links.
7824                       # We might still enter an endless loop, since a link
7825                       # loop can be closed while we follow links,
7826                       # but so what?
7827                       potlib="$potent_lib"
7828                       while test -h "$potlib" 2>/dev/null; do
7829                         potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
7830                         case $potliblink in
7831                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
7832                         *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
7833                         esac
7834                       done
7835                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
7836                          $SED -e 10q |
7837                          $EGREP "$file_magic_regex" > /dev/null; then
7838                         func_append newdeplibs " $a_deplib"
7839                         a_deplib=""
7840                         break 2
7841                       fi
7842                   done
7843                 done
7844               fi
7845               if test -n "$a_deplib" ; then
7846                 droppeddeps=yes
7847                 echo
7848                 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7849                 echo "*** I have the capability to make that library automatically link in when"
7850                 echo "*** you link to this library.  But I can only do this if you have a"
7851                 echo "*** shared version of the library, which you do not appear to have"
7852                 echo "*** because I did check the linker path looking for a file starting"
7853                 if test -z "$potlib" ; then
7854                   $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
7855                 else
7856                   $ECHO "*** with $libname and none of the candidates passed a file format test"
7857                   $ECHO "*** using a file magic. Last file checked: $potlib"
7858                 fi
7859               fi
7860               ;;
7861             *)
7862               # Add a -L argument.
7863               func_append newdeplibs " $a_deplib"
7864               ;;
7865             esac
7866           done # Gone through all deplibs.
7867           ;;
7868         match_pattern*)
7869           set dummy $deplibs_check_method; shift
7870           match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7871           for a_deplib in $deplibs; do
7872             case $a_deplib in
7873             -l*)
7874               func_stripname -l '' "$a_deplib"
7875               name=$func_stripname_result
7876               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7877                 case " $predeps $postdeps " in
7878                 *" $a_deplib "*)
7879                   func_append newdeplibs " $a_deplib"
7880                   a_deplib=""
7881                   ;;
7882                 esac
7883               fi
7884               if test -n "$a_deplib" ; then
7885                 libname=`eval "\\$ECHO \"$libname_spec\""`
7886                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7887                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7888                   for potent_lib in $potential_libs; do
7889                     potlib="$potent_lib" # see symlink-check above in file_magic test
7890                     if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
7891                        $EGREP "$match_pattern_regex" > /dev/null; then
7892                       func_append newdeplibs " $a_deplib"
7893                       a_deplib=""
7894                       break 2
7895                     fi
7896                   done
7897                 done
7898               fi
7899               if test -n "$a_deplib" ; then
7900                 droppeddeps=yes
7901                 echo
7902                 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7903                 echo "*** I have the capability to make that library automatically link in when"
7904                 echo "*** you link to this library.  But I can only do this if you have a"
7905                 echo "*** shared version of the library, which you do not appear to have"
7906                 echo "*** because I did check the linker path looking for a file starting"
7907                 if test -z "$potlib" ; then
7908                   $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
7909                 else
7910                   $ECHO "*** with $libname and none of the candidates passed a file format test"
7911                   $ECHO "*** using a regex pattern. Last file checked: $potlib"
7912                 fi
7913               fi
7914               ;;
7915             *)
7916               # Add a -L argument.
7917               func_append newdeplibs " $a_deplib"
7918               ;;
7919             esac
7920           done # Gone through all deplibs.
7921           ;;
7922         none | unknown | *)
7923           newdeplibs=""
7924           tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
7925           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7926             for i in $predeps $postdeps ; do
7927               # can't use Xsed below, because $i might contain '/'
7928               tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
7929             done
7930           fi
7931           case $tmp_deplibs in
7932           *[!\  \ ]*)
7933             echo
7934             if test "X$deplibs_check_method" = "Xnone"; then
7935               echo "*** Warning: inter-library dependencies are not supported in this platform."
7936             else
7937               echo "*** Warning: inter-library dependencies are not known to be supported."
7938             fi
7939             echo "*** All declared inter-library dependencies are being dropped."
7940             droppeddeps=yes
7941             ;;
7942           esac
7943           ;;
7944         esac
7945         versuffix=$versuffix_save
7946         major=$major_save
7947         release=$release_save
7948         libname=$libname_save
7949         name=$name_save
7950
7951         case $host in
7952         *-*-rhapsody* | *-*-darwin1.[012])
7953           # On Rhapsody replace the C library with the System framework
7954           newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
7955           ;;
7956         esac
7957
7958         if test "$droppeddeps" = yes; then
7959           if test "$module" = yes; then
7960             echo
7961             echo "*** Warning: libtool could not satisfy all declared inter-library"
7962             $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
7963             echo "*** a static module, that should work as long as the dlopening"
7964             echo "*** application is linked with the -dlopen flag."
7965             if test -z "$global_symbol_pipe"; then
7966               echo
7967               echo "*** However, this would only work if libtool was able to extract symbol"
7968               echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
7969               echo "*** not find such a program.  So, this module is probably useless."
7970               echo "*** \`nm' from GNU binutils and a full rebuild may help."
7971             fi
7972             if test "$build_old_libs" = no; then
7973               oldlibs="$output_objdir/$libname.$libext"
7974               build_libtool_libs=module
7975               build_old_libs=yes
7976             else
7977               build_libtool_libs=no
7978             fi
7979           else
7980             echo "*** The inter-library dependencies that have been dropped here will be"
7981             echo "*** automatically added whenever a program is linked with this library"
7982             echo "*** or is declared to -dlopen it."
7983
7984             if test "$allow_undefined" = no; then
7985               echo
7986               echo "*** Since this library must not contain undefined symbols,"
7987               echo "*** because either the platform does not support them or"
7988               echo "*** it was explicitly requested with -no-undefined,"
7989               echo "*** libtool will only create a static version of it."
7990               if test "$build_old_libs" = no; then
7991                 oldlibs="$output_objdir/$libname.$libext"
7992                 build_libtool_libs=module
7993                 build_old_libs=yes
7994               else
7995                 build_libtool_libs=no
7996               fi
7997             fi
7998           fi
7999         fi
8000         # Done checking deplibs!
8001         deplibs=$newdeplibs
8002       fi
8003       # Time to change all our "foo.ltframework" stuff back to "-framework foo"
8004       case $host in
8005         *-*-darwin*)
8006           newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8007           new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8008           deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8009           ;;
8010       esac
8011
8012       # move library search paths that coincide with paths to not yet
8013       # installed libraries to the beginning of the library search list
8014       new_libs=
8015       for path in $notinst_path; do
8016         case " $new_libs " in
8017         *" -L$path/$objdir "*) ;;
8018         *)
8019           case " $deplibs " in
8020           *" -L$path/$objdir "*)
8021             func_append new_libs " -L$path/$objdir" ;;
8022           esac
8023           ;;
8024         esac
8025       done
8026       for deplib in $deplibs; do
8027         case $deplib in
8028         -L*)
8029           case " $new_libs " in
8030           *" $deplib "*) ;;
8031           *) func_append new_libs " $deplib" ;;
8032           esac
8033           ;;
8034         *) func_append new_libs " $deplib" ;;
8035         esac
8036       done
8037       deplibs="$new_libs"
8038
8039       # All the library-specific variables (install_libdir is set above).
8040       library_names=
8041       old_library=
8042       dlname=
8043
8044       # Test again, we may have decided not to build it any more
8045       if test "$build_libtool_libs" = yes; then
8046         if test "$hardcode_into_libs" = yes; then
8047           # Hardcode the library paths
8048           hardcode_libdirs=
8049           dep_rpath=
8050           rpath="$finalize_rpath"
8051           test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
8052           for libdir in $rpath; do
8053             if test -n "$hardcode_libdir_flag_spec"; then
8054               if test -n "$hardcode_libdir_separator"; then
8055                 func_replace_sysroot "$libdir"
8056                 libdir=$func_replace_sysroot_result
8057                 if test -z "$hardcode_libdirs"; then
8058                   hardcode_libdirs="$libdir"
8059                 else
8060                   # Just accumulate the unique libdirs.
8061                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8062                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8063                     ;;
8064                   *)
8065                     func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8066                     ;;
8067                   esac
8068                 fi
8069               else
8070                 eval flag=\"$hardcode_libdir_flag_spec\"
8071                 func_append dep_rpath " $flag"
8072               fi
8073             elif test -n "$runpath_var"; then
8074               case "$perm_rpath " in
8075               *" $libdir "*) ;;
8076               *) func_append perm_rpath " $libdir" ;;
8077               esac
8078             fi
8079           done
8080           # Substitute the hardcoded libdirs into the rpath.
8081           if test -n "$hardcode_libdir_separator" &&
8082              test -n "$hardcode_libdirs"; then
8083             libdir="$hardcode_libdirs"
8084             if test -n "$hardcode_libdir_flag_spec_ld"; then
8085               eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
8086             else
8087               eval dep_rpath=\"$hardcode_libdir_flag_spec\"
8088             fi
8089           fi
8090           if test -n "$runpath_var" && test -n "$perm_rpath"; then
8091             # We should set the runpath_var.
8092             rpath=
8093             for dir in $perm_rpath; do
8094               func_append rpath "$dir:"
8095             done
8096             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
8097           fi
8098           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
8099         fi
8100
8101         shlibpath="$finalize_shlibpath"
8102         test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
8103         if test -n "$shlibpath"; then
8104           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
8105         fi
8106
8107         # Get the real and link names of the library.
8108         eval shared_ext=\"$shrext_cmds\"
8109         eval library_names=\"$library_names_spec\"
8110         set dummy $library_names
8111         shift
8112         realname="$1"
8113         shift
8114
8115         if test -n "$soname_spec"; then
8116           eval soname=\"$soname_spec\"
8117         else
8118           soname="$realname"
8119         fi
8120         if test -z "$dlname"; then
8121           dlname=$soname
8122         fi
8123
8124         lib="$output_objdir/$realname"
8125         linknames=
8126         for link
8127         do
8128           func_append linknames " $link"
8129         done
8130
8131         # Use standard objects if they are pic
8132         test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
8133         test "X$libobjs" = "X " && libobjs=
8134
8135         delfiles=
8136         if test -n "$export_symbols" && test -n "$include_expsyms"; then
8137           $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
8138           export_symbols="$output_objdir/$libname.uexp"
8139           func_append delfiles " $export_symbols"
8140         fi
8141
8142         orig_export_symbols=
8143         case $host_os in
8144         cygwin* | mingw* | cegcc*)
8145           if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
8146             # exporting using user supplied symfile
8147             if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
8148               # and it's NOT already a .def file. Must figure out
8149               # which of the given symbols are data symbols and tag
8150               # them as such. So, trigger use of export_symbols_cmds.
8151               # export_symbols gets reassigned inside the "prepare
8152               # the list of exported symbols" if statement, so the
8153               # include_expsyms logic still works.
8154               orig_export_symbols="$export_symbols"
8155               export_symbols=
8156               always_export_symbols=yes
8157             fi
8158           fi
8159           ;;
8160         esac
8161
8162         # Prepare the list of exported symbols
8163         if test -z "$export_symbols"; then
8164           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
8165             func_verbose "generating symbol list for \`$libname.la'"
8166             export_symbols="$output_objdir/$libname.exp"
8167             $opt_dry_run || $RM $export_symbols
8168             cmds=$export_symbols_cmds
8169             save_ifs="$IFS"; IFS='~'
8170             for cmd1 in $cmds; do
8171               IFS="$save_ifs"
8172               # Take the normal branch if the nm_file_list_spec branch
8173               # doesn't work or if tool conversion is not needed.
8174               case $nm_file_list_spec~$to_tool_file_cmd in
8175                 *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
8176                   try_normal_branch=yes
8177                   eval cmd=\"$cmd1\"
8178                   func_len " $cmd"
8179                   len=$func_len_result
8180                   ;;
8181                 *)
8182                   try_normal_branch=no
8183                   ;;
8184               esac
8185               if test "$try_normal_branch" = yes \
8186                  && { test "$len" -lt "$max_cmd_len" \
8187                       || test "$max_cmd_len" -le -1; }
8188               then
8189                 func_show_eval "$cmd" 'exit $?'
8190                 skipped_export=false
8191               elif test -n "$nm_file_list_spec"; then
8192                 func_basename "$output"
8193                 output_la=$func_basename_result
8194                 save_libobjs=$libobjs
8195                 save_output=$output
8196                 output=${output_objdir}/${output_la}.nm
8197                 func_to_tool_file "$output"
8198                 libobjs=$nm_file_list_spec$func_to_tool_file_result
8199                 func_append delfiles " $output"
8200                 func_verbose "creating $NM input file list: $output"
8201                 for obj in $save_libobjs; do
8202                   func_to_tool_file "$obj"
8203                   $ECHO "$func_to_tool_file_result"
8204                 done > "$output"
8205                 eval cmd=\"$cmd1\"
8206                 func_show_eval "$cmd" 'exit $?'
8207                 output=$save_output
8208                 libobjs=$save_libobjs
8209                 skipped_export=false
8210               else
8211                 # The command line is too long to execute in one step.
8212                 func_verbose "using reloadable object file for export list..."
8213                 skipped_export=:
8214                 # Break out early, otherwise skipped_export may be
8215                 # set to false by a later but shorter cmd.
8216                 break
8217               fi
8218             done
8219             IFS="$save_ifs"
8220             if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
8221               func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8222               func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8223             fi
8224           fi
8225         fi
8226
8227         if test -n "$export_symbols" && test -n "$include_expsyms"; then
8228           tmp_export_symbols="$export_symbols"
8229           test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8230           $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8231         fi
8232
8233         if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
8234           # The given exports_symbols file has to be filtered, so filter it.
8235           func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8236           # FIXME: $output_objdir/$libname.filter potentially contains lots of
8237           # 's' commands which not all seds can handle. GNU sed should be fine
8238           # though. Also, the filter scales superlinearly with the number of
8239           # global variables. join(1) would be nice here, but unfortunately
8240           # isn't a blessed tool.
8241           $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8242           func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8243           export_symbols=$output_objdir/$libname.def
8244           $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8245         fi
8246
8247         tmp_deplibs=
8248         for test_deplib in $deplibs; do
8249           case " $convenience " in
8250           *" $test_deplib "*) ;;
8251           *)
8252             func_append tmp_deplibs " $test_deplib"
8253             ;;
8254           esac
8255         done
8256         deplibs="$tmp_deplibs"
8257
8258         if test -n "$convenience"; then
8259           if test -n "$whole_archive_flag_spec" &&
8260             test "$compiler_needs_object" = yes &&
8261             test -z "$libobjs"; then
8262             # extract the archives, so we have objects to list.
8263             # TODO: could optimize this to just extract one archive.
8264             whole_archive_flag_spec=
8265           fi
8266           if test -n "$whole_archive_flag_spec"; then
8267             save_libobjs=$libobjs
8268             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8269             test "X$libobjs" = "X " && libobjs=
8270           else
8271             gentop="$output_objdir/${outputname}x"
8272             func_append generated " $gentop"
8273
8274             func_extract_archives $gentop $convenience
8275             func_append libobjs " $func_extract_archives_result"
8276             test "X$libobjs" = "X " && libobjs=
8277           fi
8278         fi
8279
8280         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
8281           eval flag=\"$thread_safe_flag_spec\"
8282           func_append linker_flags " $flag"
8283         fi
8284
8285         # Make a backup of the uninstalled library when relinking
8286         if test "$opt_mode" = relink; then
8287           $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
8288         fi
8289
8290         # Do each of the archive commands.
8291         if test "$module" = yes && test -n "$module_cmds" ; then
8292           if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8293             eval test_cmds=\"$module_expsym_cmds\"
8294             cmds=$module_expsym_cmds
8295           else
8296             eval test_cmds=\"$module_cmds\"
8297             cmds=$module_cmds
8298           fi
8299         else
8300           if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8301             eval test_cmds=\"$archive_expsym_cmds\"
8302             cmds=$archive_expsym_cmds
8303           else
8304             eval test_cmds=\"$archive_cmds\"
8305             cmds=$archive_cmds
8306           fi
8307         fi
8308
8309         if test "X$skipped_export" != "X:" &&
8310            func_len " $test_cmds" &&
8311            len=$func_len_result &&
8312            test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8313           :
8314         else
8315           # The command line is too long to link in one step, link piecewise
8316           # or, if using GNU ld and skipped_export is not :, use a linker
8317           # script.
8318
8319           # Save the value of $output and $libobjs because we want to
8320           # use them later.  If we have whole_archive_flag_spec, we
8321           # want to use save_libobjs as it was before
8322           # whole_archive_flag_spec was expanded, because we can't
8323           # assume the linker understands whole_archive_flag_spec.
8324           # This may have to be revisited, in case too many
8325           # convenience libraries get linked in and end up exceeding
8326           # the spec.
8327           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
8328             save_libobjs=$libobjs
8329           fi
8330           save_output=$output
8331           func_basename "$output"
8332           output_la=$func_basename_result
8333
8334           # Clear the reloadable object creation command queue and
8335           # initialize k to one.
8336           test_cmds=
8337           concat_cmds=
8338           objlist=
8339           last_robj=
8340           k=1
8341
8342           if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
8343             output=${output_objdir}/${output_la}.lnkscript
8344             func_verbose "creating GNU ld script: $output"
8345             echo 'INPUT (' > $output
8346             for obj in $save_libobjs
8347             do
8348               func_to_tool_file "$obj"
8349               $ECHO "$func_to_tool_file_result" >> $output
8350             done
8351             echo ')' >> $output
8352             func_append delfiles " $output"
8353             func_to_tool_file "$output"
8354             output=$func_to_tool_file_result
8355           elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
8356             output=${output_objdir}/${output_la}.lnk
8357             func_verbose "creating linker input file list: $output"
8358             : > $output
8359             set x $save_libobjs
8360             shift
8361             firstobj=
8362             if test "$compiler_needs_object" = yes; then
8363               firstobj="$1 "
8364               shift
8365             fi
8366             for obj
8367             do
8368               func_to_tool_file "$obj"
8369               $ECHO "$func_to_tool_file_result" >> $output
8370             done
8371             func_append delfiles " $output"
8372             func_to_tool_file "$output"
8373             output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
8374           else
8375             if test -n "$save_libobjs"; then
8376               func_verbose "creating reloadable object files..."
8377               output=$output_objdir/$output_la-${k}.$objext
8378               eval test_cmds=\"$reload_cmds\"
8379               func_len " $test_cmds"
8380               len0=$func_len_result
8381               len=$len0
8382
8383               # Loop over the list of objects to be linked.
8384               for obj in $save_libobjs
8385               do
8386                 func_len " $obj"
8387                 func_arith $len + $func_len_result
8388                 len=$func_arith_result
8389                 if test "X$objlist" = X ||
8390                    test "$len" -lt "$max_cmd_len"; then
8391                   func_append objlist " $obj"
8392                 else
8393                   # The command $test_cmds is almost too long, add a
8394                   # command to the queue.
8395                   if test "$k" -eq 1 ; then
8396                     # The first file doesn't have a previous command to add.
8397                     reload_objs=$objlist
8398                     eval concat_cmds=\"$reload_cmds\"
8399                   else
8400                     # All subsequent reloadable object files will link in
8401                     # the last one created.
8402                     reload_objs="$objlist $last_robj"
8403                     eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
8404                   fi
8405                   last_robj=$output_objdir/$output_la-${k}.$objext
8406                   func_arith $k + 1
8407                   k=$func_arith_result
8408                   output=$output_objdir/$output_la-${k}.$objext
8409                   objlist=" $obj"
8410                   func_len " $last_robj"
8411                   func_arith $len0 + $func_len_result
8412                   len=$func_arith_result
8413                 fi
8414               done
8415               # Handle the remaining objects by creating one last
8416               # reloadable object file.  All subsequent reloadable object
8417               # files will link in the last one created.
8418               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8419               reload_objs="$objlist $last_robj"
8420               eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
8421               if test -n "$last_robj"; then
8422                 eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
8423               fi
8424               func_append delfiles " $output"
8425
8426             else
8427               output=
8428             fi
8429
8430             if ${skipped_export-false}; then
8431               func_verbose "generating symbol list for \`$libname.la'"
8432               export_symbols="$output_objdir/$libname.exp"
8433               $opt_dry_run || $RM $export_symbols
8434               libobjs=$output
8435               # Append the command to create the export file.
8436               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8437               eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
8438               if test -n "$last_robj"; then
8439                 eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
8440               fi
8441             fi
8442
8443             test -n "$save_libobjs" &&
8444               func_verbose "creating a temporary reloadable object file: $output"
8445
8446             # Loop through the commands generated above and execute them.
8447             save_ifs="$IFS"; IFS='~'
8448             for cmd in $concat_cmds; do
8449               IFS="$save_ifs"
8450               $opt_silent || {
8451                   func_quote_for_expand "$cmd"
8452                   eval "func_echo $func_quote_for_expand_result"
8453               }
8454               $opt_dry_run || eval "$cmd" || {
8455                 lt_exit=$?
8456
8457                 # Restore the uninstalled library and exit
8458                 if test "$opt_mode" = relink; then
8459                   ( cd "$output_objdir" && \
8460                     $RM "${realname}T" && \
8461                     $MV "${realname}U" "$realname" )
8462                 fi
8463
8464                 exit $lt_exit
8465               }
8466             done
8467             IFS="$save_ifs"
8468
8469             if test -n "$export_symbols_regex" && ${skipped_export-false}; then
8470               func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8471               func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8472             fi
8473           fi
8474
8475           if ${skipped_export-false}; then
8476             if test -n "$export_symbols" && test -n "$include_expsyms"; then
8477               tmp_export_symbols="$export_symbols"
8478               test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8479               $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8480             fi
8481
8482             if test -n "$orig_export_symbols"; then
8483               # The given exports_symbols file has to be filtered, so filter it.
8484               func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8485               # FIXME: $output_objdir/$libname.filter potentially contains lots of
8486               # 's' commands which not all seds can handle. GNU sed should be fine
8487               # though. Also, the filter scales superlinearly with the number of
8488               # global variables. join(1) would be nice here, but unfortunately
8489               # isn't a blessed tool.
8490               $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8491               func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8492               export_symbols=$output_objdir/$libname.def
8493               $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8494             fi
8495           fi
8496
8497           libobjs=$output
8498           # Restore the value of output.
8499           output=$save_output
8500
8501           if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
8502             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8503             test "X$libobjs" = "X " && libobjs=
8504           fi
8505           # Expand the library linking commands again to reset the
8506           # value of $libobjs for piecewise linking.
8507
8508           # Do each of the archive commands.
8509           if test "$module" = yes && test -n "$module_cmds" ; then
8510             if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8511               cmds=$module_expsym_cmds
8512             else
8513               cmds=$module_cmds
8514             fi
8515           else
8516             if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8517               cmds=$archive_expsym_cmds
8518             else
8519               cmds=$archive_cmds
8520             fi
8521           fi
8522         fi
8523
8524         if test -n "$delfiles"; then
8525           # Append the command to remove temporary files to $cmds.
8526           eval cmds=\"\$cmds~\$RM $delfiles\"
8527         fi
8528
8529         # Add any objects from preloaded convenience libraries
8530         if test -n "$dlprefiles"; then
8531           gentop="$output_objdir/${outputname}x"
8532           func_append generated " $gentop"
8533
8534           func_extract_archives $gentop $dlprefiles
8535           func_append libobjs " $func_extract_archives_result"
8536           test "X$libobjs" = "X " && libobjs=
8537         fi
8538
8539         save_ifs="$IFS"; IFS='~'
8540         for cmd in $cmds; do
8541           IFS="$save_ifs"
8542           eval cmd=\"$cmd\"
8543           $opt_silent || {
8544             func_quote_for_expand "$cmd"
8545             eval "func_echo $func_quote_for_expand_result"
8546           }
8547           $opt_dry_run || eval "$cmd" || {
8548             lt_exit=$?
8549
8550             # Restore the uninstalled library and exit
8551             if test "$opt_mode" = relink; then
8552               ( cd "$output_objdir" && \
8553                 $RM "${realname}T" && \
8554                 $MV "${realname}U" "$realname" )
8555             fi
8556
8557             exit $lt_exit
8558           }
8559         done
8560         IFS="$save_ifs"
8561
8562         # Restore the uninstalled library and exit
8563         if test "$opt_mode" = relink; then
8564           $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
8565
8566           if test -n "$convenience"; then
8567             if test -z "$whole_archive_flag_spec"; then
8568               func_show_eval '${RM}r "$gentop"'
8569             fi
8570           fi
8571
8572           exit $EXIT_SUCCESS
8573         fi
8574
8575         # Create links to the real library.
8576         for linkname in $linknames; do
8577           if test "$realname" != "$linkname"; then
8578             func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
8579           fi
8580         done
8581
8582         # If -module or -export-dynamic was specified, set the dlname.
8583         if test "$module" = yes || test "$export_dynamic" = yes; then
8584           # On all known operating systems, these are identical.
8585           dlname="$soname"
8586         fi
8587       fi
8588       ;;
8589
8590     obj)
8591       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
8592         func_warning "\`-dlopen' is ignored for objects"
8593       fi
8594
8595       case " $deplibs" in
8596       *\ -l* | *\ -L*)
8597         func_warning "\`-l' and \`-L' are ignored for objects" ;;
8598       esac
8599
8600       test -n "$rpath" && \
8601         func_warning "\`-rpath' is ignored for objects"
8602
8603       test -n "$xrpath" && \
8604         func_warning "\`-R' is ignored for objects"
8605
8606       test -n "$vinfo" && \
8607         func_warning "\`-version-info' is ignored for objects"
8608
8609       test -n "$release" && \
8610         func_warning "\`-release' is ignored for objects"
8611
8612       case $output in
8613       *.lo)
8614         test -n "$objs$old_deplibs" && \
8615           func_fatal_error "cannot build library object \`$output' from non-libtool objects"
8616
8617         libobj=$output
8618         func_lo2o "$libobj"
8619         obj=$func_lo2o_result
8620         ;;
8621       *)
8622         libobj=
8623         obj="$output"
8624         ;;
8625       esac
8626
8627       # Delete the old objects.
8628       $opt_dry_run || $RM $obj $libobj
8629
8630       # Objects from convenience libraries.  This assumes
8631       # single-version convenience libraries.  Whenever we create
8632       # different ones for PIC/non-PIC, this we'll have to duplicate
8633       # the extraction.
8634       reload_conv_objs=
8635       gentop=
8636       # reload_cmds runs $LD directly, so let us get rid of
8637       # -Wl from whole_archive_flag_spec and hope we can get by with
8638       # turning comma into space..
8639       wl=
8640
8641       if test -n "$convenience"; then
8642         if test -n "$whole_archive_flag_spec"; then
8643           eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
8644           reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
8645         else
8646           gentop="$output_objdir/${obj}x"
8647           func_append generated " $gentop"
8648
8649           func_extract_archives $gentop $convenience
8650           reload_conv_objs="$reload_objs $func_extract_archives_result"
8651         fi
8652       fi
8653
8654       # If we're not building shared, we need to use non_pic_objs
8655       test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
8656
8657       # Create the old-style object.
8658       reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
8659
8660       output="$obj"
8661       func_execute_cmds "$reload_cmds" 'exit $?'
8662
8663       # Exit if we aren't doing a library object file.
8664       if test -z "$libobj"; then
8665         if test -n "$gentop"; then
8666           func_show_eval '${RM}r "$gentop"'
8667         fi
8668
8669         exit $EXIT_SUCCESS
8670       fi
8671
8672       if test "$build_libtool_libs" != yes; then
8673         if test -n "$gentop"; then
8674           func_show_eval '${RM}r "$gentop"'
8675         fi
8676
8677         # Create an invalid libtool object if no PIC, so that we don't
8678         # accidentally link it into a program.
8679         # $show "echo timestamp > $libobj"
8680         # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
8681         exit $EXIT_SUCCESS
8682       fi
8683
8684       if test -n "$pic_flag" || test "$pic_mode" != default; then
8685         # Only do commands if we really have different PIC objects.
8686         reload_objs="$libobjs $reload_conv_objs"
8687         output="$libobj"
8688         func_execute_cmds "$reload_cmds" 'exit $?'
8689       fi
8690
8691       if test -n "$gentop"; then
8692         func_show_eval '${RM}r "$gentop"'
8693       fi
8694
8695       exit $EXIT_SUCCESS
8696       ;;
8697
8698     prog)
8699       case $host in
8700         *cygwin*) func_stripname '' '.exe' "$output"
8701                   output=$func_stripname_result.exe;;
8702       esac
8703       test -n "$vinfo" && \
8704         func_warning "\`-version-info' is ignored for programs"
8705
8706       test -n "$release" && \
8707         func_warning "\`-release' is ignored for programs"
8708
8709       test "$preload" = yes \
8710         && test "$dlopen_support" = unknown \
8711         && test "$dlopen_self" = unknown \
8712         && test "$dlopen_self_static" = unknown && \
8713           func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
8714
8715       case $host in
8716       *-*-rhapsody* | *-*-darwin1.[012])
8717         # On Rhapsody replace the C library is the System framework
8718         compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
8719         finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
8720         ;;
8721       esac
8722
8723       case $host in
8724       *-*-darwin*)
8725         # Don't allow lazy linking, it breaks C++ global constructors
8726         # But is supposedly fixed on 10.4 or later (yay!).
8727         if test "$tagname" = CXX ; then
8728           case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
8729             10.[0123])
8730               func_append compile_command " ${wl}-bind_at_load"
8731               func_append finalize_command " ${wl}-bind_at_load"
8732             ;;
8733           esac
8734         fi
8735         # Time to change all our "foo.ltframework" stuff back to "-framework foo"
8736         compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8737         finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8738         ;;
8739       esac
8740
8741
8742       # move library search paths that coincide with paths to not yet
8743       # installed libraries to the beginning of the library search list
8744       new_libs=
8745       for path in $notinst_path; do
8746         case " $new_libs " in
8747         *" -L$path/$objdir "*) ;;
8748         *)
8749           case " $compile_deplibs " in
8750           *" -L$path/$objdir "*)
8751             func_append new_libs " -L$path/$objdir" ;;
8752           esac
8753           ;;
8754         esac
8755       done
8756       for deplib in $compile_deplibs; do
8757         case $deplib in
8758         -L*)
8759           case " $new_libs " in
8760           *" $deplib "*) ;;
8761           *) func_append new_libs " $deplib" ;;
8762           esac
8763           ;;
8764         *) func_append new_libs " $deplib" ;;
8765         esac
8766       done
8767       compile_deplibs="$new_libs"
8768
8769
8770       func_append compile_command " $compile_deplibs"
8771       func_append finalize_command " $finalize_deplibs"
8772
8773       if test -n "$rpath$xrpath"; then
8774         # If the user specified any rpath flags, then add them.
8775         for libdir in $rpath $xrpath; do
8776           # This is the magic to use -rpath.
8777           case "$finalize_rpath " in
8778           *" $libdir "*) ;;
8779           *) func_append finalize_rpath " $libdir" ;;
8780           esac
8781         done
8782       fi
8783
8784       # Now hardcode the library paths
8785       rpath=
8786       hardcode_libdirs=
8787       for libdir in $compile_rpath $finalize_rpath; do
8788         if test -n "$hardcode_libdir_flag_spec"; then
8789           if test -n "$hardcode_libdir_separator"; then
8790             if test -z "$hardcode_libdirs"; then
8791               hardcode_libdirs="$libdir"
8792             else
8793               # Just accumulate the unique libdirs.
8794               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8795               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8796                 ;;
8797               *)
8798                 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8799                 ;;
8800               esac
8801             fi
8802           else
8803             eval flag=\"$hardcode_libdir_flag_spec\"
8804             func_append rpath " $flag"
8805           fi
8806         elif test -n "$runpath_var"; then
8807           case "$perm_rpath " in
8808           *" $libdir "*) ;;
8809           *) func_append perm_rpath " $libdir" ;;
8810           esac
8811         fi
8812         case $host in
8813         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
8814           testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
8815           case :$dllsearchpath: in
8816           *":$libdir:"*) ;;
8817           ::) dllsearchpath=$libdir;;
8818           *) func_append dllsearchpath ":$libdir";;
8819           esac
8820           case :$dllsearchpath: in
8821           *":$testbindir:"*) ;;
8822           ::) dllsearchpath=$testbindir;;
8823           *) func_append dllsearchpath ":$testbindir";;
8824           esac
8825           ;;
8826         esac
8827       done
8828       # Substitute the hardcoded libdirs into the rpath.
8829       if test -n "$hardcode_libdir_separator" &&
8830          test -n "$hardcode_libdirs"; then
8831         libdir="$hardcode_libdirs"
8832         eval rpath=\" $hardcode_libdir_flag_spec\"
8833       fi
8834       compile_rpath="$rpath"
8835
8836       rpath=
8837       hardcode_libdirs=
8838       for libdir in $finalize_rpath; do
8839         if test -n "$hardcode_libdir_flag_spec"; then
8840           if test -n "$hardcode_libdir_separator"; then
8841             if test -z "$hardcode_libdirs"; then
8842               hardcode_libdirs="$libdir"
8843             else
8844               # Just accumulate the unique libdirs.
8845               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8846               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8847                 ;;
8848               *)
8849                 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8850                 ;;
8851               esac
8852             fi
8853           else
8854             eval flag=\"$hardcode_libdir_flag_spec\"
8855             func_append rpath " $flag"
8856           fi
8857         elif test -n "$runpath_var"; then
8858           case "$finalize_perm_rpath " in
8859           *" $libdir "*) ;;
8860           *) func_append finalize_perm_rpath " $libdir" ;;
8861           esac
8862         fi
8863       done
8864       # Substitute the hardcoded libdirs into the rpath.
8865       if test -n "$hardcode_libdir_separator" &&
8866          test -n "$hardcode_libdirs"; then
8867         libdir="$hardcode_libdirs"
8868         eval rpath=\" $hardcode_libdir_flag_spec\"
8869       fi
8870       finalize_rpath="$rpath"
8871
8872       if test -n "$libobjs" && test "$build_old_libs" = yes; then
8873         # Transform all the library objects into standard objects.
8874         compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8875         finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8876       fi
8877
8878       func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
8879
8880       # template prelinking step
8881       if test -n "$prelink_cmds"; then
8882         func_execute_cmds "$prelink_cmds" 'exit $?'
8883       fi
8884
8885       wrappers_required=yes
8886       case $host in
8887       *cegcc* | *mingw32ce*)
8888         # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
8889         wrappers_required=no
8890         ;;
8891       *cygwin* | *mingw* )
8892         if test "$build_libtool_libs" != yes; then
8893           wrappers_required=no
8894         fi
8895         ;;
8896       *)
8897         if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
8898           wrappers_required=no
8899         fi
8900         ;;
8901       esac
8902       if test "$wrappers_required" = no; then
8903         # Replace the output file specification.
8904         compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8905         link_command="$compile_command$compile_rpath"
8906
8907         # We have no uninstalled library dependencies, so finalize right now.
8908         exit_status=0
8909         func_show_eval "$link_command" 'exit_status=$?'
8910
8911         if test -n "$postlink_cmds"; then
8912           func_to_tool_file "$output"
8913           postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8914           func_execute_cmds "$postlink_cmds" 'exit $?'
8915         fi
8916
8917         # Delete the generated files.
8918         if test -f "$output_objdir/${outputname}S.${objext}"; then
8919           func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
8920         fi
8921
8922         exit $exit_status
8923       fi
8924
8925       if test -n "$compile_shlibpath$finalize_shlibpath"; then
8926         compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
8927       fi
8928       if test -n "$finalize_shlibpath"; then
8929         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
8930       fi
8931
8932       compile_var=
8933       finalize_var=
8934       if test -n "$runpath_var"; then
8935         if test -n "$perm_rpath"; then
8936           # We should set the runpath_var.
8937           rpath=
8938           for dir in $perm_rpath; do
8939             func_append rpath "$dir:"
8940           done
8941           compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
8942         fi
8943         if test -n "$finalize_perm_rpath"; then
8944           # We should set the runpath_var.
8945           rpath=
8946           for dir in $finalize_perm_rpath; do
8947             func_append rpath "$dir:"
8948           done
8949           finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
8950         fi
8951       fi
8952
8953       if test "$no_install" = yes; then
8954         # We don't need to create a wrapper script.
8955         link_command="$compile_var$compile_command$compile_rpath"
8956         # Replace the output file specification.
8957         link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8958         # Delete the old output file.
8959         $opt_dry_run || $RM $output
8960         # Link the executable and exit
8961         func_show_eval "$link_command" 'exit $?'
8962
8963         if test -n "$postlink_cmds"; then
8964           func_to_tool_file "$output"
8965           postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8966           func_execute_cmds "$postlink_cmds" 'exit $?'
8967         fi
8968
8969         exit $EXIT_SUCCESS
8970       fi
8971
8972       if test "$hardcode_action" = relink; then
8973         # Fast installation is not supported
8974         link_command="$compile_var$compile_command$compile_rpath"
8975         relink_command="$finalize_var$finalize_command$finalize_rpath"
8976
8977         func_warning "this platform does not like uninstalled shared libraries"
8978         func_warning "\`$output' will be relinked during installation"
8979       else
8980         if test "$fast_install" != no; then
8981           link_command="$finalize_var$compile_command$finalize_rpath"
8982           if test "$fast_install" = yes; then
8983             relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
8984           else
8985             # fast_install is set to needless
8986             relink_command=
8987           fi
8988         else
8989           link_command="$compile_var$compile_command$compile_rpath"
8990           relink_command="$finalize_var$finalize_command$finalize_rpath"
8991         fi
8992       fi
8993
8994       # Replace the output file specification.
8995       link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8996
8997       # Delete the old output files.
8998       $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8999
9000       func_show_eval "$link_command" 'exit $?'
9001
9002       if test -n "$postlink_cmds"; then
9003         func_to_tool_file "$output_objdir/$outputname"
9004         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'`
9005         func_execute_cmds "$postlink_cmds" 'exit $?'
9006       fi
9007
9008       # Now create the wrapper script.
9009       func_verbose "creating $output"
9010
9011       # Quote the relink command for shipping.
9012       if test -n "$relink_command"; then
9013         # Preserve any variables that may affect compiler behavior
9014         for var in $variables_saved_for_relink; do
9015           if eval test -z \"\${$var+set}\"; then
9016             relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9017           elif eval var_value=\$$var; test -z "$var_value"; then
9018             relink_command="$var=; export $var; $relink_command"
9019           else
9020             func_quote_for_eval "$var_value"
9021             relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9022           fi
9023         done
9024         relink_command="(cd `pwd`; $relink_command)"
9025         relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9026       fi
9027
9028       # Only actually do things if not in dry run mode.
9029       $opt_dry_run || {
9030         # win32 will think the script is a binary if it has
9031         # a .exe suffix, so we strip it off here.
9032         case $output in
9033           *.exe) func_stripname '' '.exe' "$output"
9034                  output=$func_stripname_result ;;
9035         esac
9036         # test for cygwin because mv fails w/o .exe extensions
9037         case $host in
9038           *cygwin*)
9039             exeext=.exe
9040             func_stripname '' '.exe' "$outputname"
9041             outputname=$func_stripname_result ;;
9042           *) exeext= ;;
9043         esac
9044         case $host in
9045           *cygwin* | *mingw* )
9046             func_dirname_and_basename "$output" "" "."
9047             output_name=$func_basename_result
9048             output_path=$func_dirname_result
9049             cwrappersource="$output_path/$objdir/lt-$output_name.c"
9050             cwrapper="$output_path/$output_name.exe"
9051             $RM $cwrappersource $cwrapper
9052             trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
9053
9054             func_emit_cwrapperexe_src > $cwrappersource
9055
9056             # The wrapper executable is built using the $host compiler,
9057             # because it contains $host paths and files. If cross-
9058             # compiling, it, like the target executable, must be
9059             # executed on the $host or under an emulation environment.
9060             $opt_dry_run || {
9061               $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
9062               $STRIP $cwrapper
9063             }
9064
9065             # Now, create the wrapper script for func_source use:
9066             func_ltwrapper_scriptname $cwrapper
9067             $RM $func_ltwrapper_scriptname_result
9068             trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
9069             $opt_dry_run || {
9070               # note: this script will not be executed, so do not chmod.
9071               if test "x$build" = "x$host" ; then
9072                 $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
9073               else
9074                 func_emit_wrapper no > $func_ltwrapper_scriptname_result
9075               fi
9076             }
9077           ;;
9078           * )
9079             $RM $output
9080             trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
9081
9082             func_emit_wrapper no > $output
9083             chmod +x $output
9084           ;;
9085         esac
9086       }
9087       exit $EXIT_SUCCESS
9088       ;;
9089     esac
9090
9091     # See if we need to build an old-fashioned archive.
9092     for oldlib in $oldlibs; do
9093
9094       if test "$build_libtool_libs" = convenience; then
9095         oldobjs="$libobjs_save $symfileobj"
9096         addlibs="$convenience"
9097         build_libtool_libs=no
9098       else
9099         if test "$build_libtool_libs" = module; then
9100           oldobjs="$libobjs_save"
9101           build_libtool_libs=no
9102         else
9103           oldobjs="$old_deplibs $non_pic_objects"
9104           if test "$preload" = yes && test -f "$symfileobj"; then
9105             func_append oldobjs " $symfileobj"
9106           fi
9107         fi
9108         addlibs="$old_convenience"
9109       fi
9110
9111       if test -n "$addlibs"; then
9112         gentop="$output_objdir/${outputname}x"
9113         func_append generated " $gentop"
9114
9115         func_extract_archives $gentop $addlibs
9116         func_append oldobjs " $func_extract_archives_result"
9117       fi
9118
9119       # Do each command in the archive commands.
9120       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
9121         cmds=$old_archive_from_new_cmds
9122       else
9123
9124         # Add any objects from preloaded convenience libraries
9125         if test -n "$dlprefiles"; then
9126           gentop="$output_objdir/${outputname}x"
9127           func_append generated " $gentop"
9128
9129           func_extract_archives $gentop $dlprefiles
9130           func_append oldobjs " $func_extract_archives_result"
9131         fi
9132
9133         # POSIX demands no paths to be encoded in archives.  We have
9134         # to avoid creating archives with duplicate basenames if we
9135         # might have to extract them afterwards, e.g., when creating a
9136         # static archive out of a convenience library, or when linking
9137         # the entirety of a libtool archive into another (currently
9138         # not supported by libtool).
9139         if (for obj in $oldobjs
9140             do
9141               func_basename "$obj"
9142               $ECHO "$func_basename_result"
9143             done | sort | sort -uc >/dev/null 2>&1); then
9144           :
9145         else
9146           echo "copying selected object files to avoid basename conflicts..."
9147           gentop="$output_objdir/${outputname}x"
9148           func_append generated " $gentop"
9149           func_mkdir_p "$gentop"
9150           save_oldobjs=$oldobjs
9151           oldobjs=
9152           counter=1
9153           for obj in $save_oldobjs
9154           do
9155             func_basename "$obj"
9156             objbase="$func_basename_result"
9157             case " $oldobjs " in
9158             " ") oldobjs=$obj ;;
9159             *[\ /]"$objbase "*)
9160               while :; do
9161                 # Make sure we don't pick an alternate name that also
9162                 # overlaps.
9163                 newobj=lt$counter-$objbase
9164                 func_arith $counter + 1
9165                 counter=$func_arith_result
9166                 case " $oldobjs " in
9167                 *[\ /]"$newobj "*) ;;
9168                 *) if test ! -f "$gentop/$newobj"; then break; fi ;;
9169                 esac
9170               done
9171               func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
9172               func_append oldobjs " $gentop/$newobj"
9173               ;;
9174             *) func_append oldobjs " $obj" ;;
9175             esac
9176           done
9177         fi
9178         eval cmds=\"$old_archive_cmds\"
9179
9180         func_len " $cmds"
9181         len=$func_len_result
9182         if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
9183           cmds=$old_archive_cmds
9184         elif test -n "$archiver_list_spec"; then
9185           func_verbose "using command file archive linking..."
9186           for obj in $oldobjs
9187           do
9188             func_to_tool_file "$obj"
9189             $ECHO "$func_to_tool_file_result"
9190           done > $output_objdir/$libname.libcmd
9191           func_to_tool_file "$output_objdir/$libname.libcmd"
9192           oldobjs=" $archiver_list_spec$func_to_tool_file_result"
9193           cmds=$old_archive_cmds
9194         else
9195           # the command line is too long to link in one step, link in parts
9196           func_verbose "using piecewise archive linking..."
9197           save_RANLIB=$RANLIB
9198           RANLIB=:
9199           objlist=
9200           concat_cmds=
9201           save_oldobjs=$oldobjs
9202           oldobjs=
9203           # Is there a better way of finding the last object in the list?
9204           for obj in $save_oldobjs
9205           do
9206             last_oldobj=$obj
9207           done
9208           eval test_cmds=\"$old_archive_cmds\"
9209           func_len " $test_cmds"
9210           len0=$func_len_result
9211           len=$len0
9212           for obj in $save_oldobjs
9213           do
9214             func_len " $obj"
9215             func_arith $len + $func_len_result
9216             len=$func_arith_result
9217             func_append objlist " $obj"
9218             if test "$len" -lt "$max_cmd_len"; then
9219               :
9220             else
9221               # the above command should be used before it gets too long
9222               oldobjs=$objlist
9223               if test "$obj" = "$last_oldobj" ; then
9224                 RANLIB=$save_RANLIB
9225               fi
9226               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
9227               eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
9228               objlist=
9229               len=$len0
9230             fi
9231           done
9232           RANLIB=$save_RANLIB
9233           oldobjs=$objlist
9234           if test "X$oldobjs" = "X" ; then
9235             eval cmds=\"\$concat_cmds\"
9236           else
9237             eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
9238           fi
9239         fi
9240       fi
9241       func_execute_cmds "$cmds" 'exit $?'
9242     done
9243
9244     test -n "$generated" && \
9245       func_show_eval "${RM}r$generated"
9246
9247     # Now create the libtool archive.
9248     case $output in
9249     *.la)
9250       old_library=
9251       test "$build_old_libs" = yes && old_library="$libname.$libext"
9252       func_verbose "creating $output"
9253
9254       # Preserve any variables that may affect compiler behavior
9255       for var in $variables_saved_for_relink; do
9256         if eval test -z \"\${$var+set}\"; then
9257           relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9258         elif eval var_value=\$$var; test -z "$var_value"; then
9259           relink_command="$var=; export $var; $relink_command"
9260         else
9261           func_quote_for_eval "$var_value"
9262           relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9263         fi
9264       done
9265       # Quote the link command for shipping.
9266       relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
9267       relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9268       if test "$hardcode_automatic" = yes ; then
9269         relink_command=
9270       fi
9271
9272       # Only create the output if not a dry run.
9273       $opt_dry_run || {
9274         for installed in no yes; do
9275           if test "$installed" = yes; then
9276             if test -z "$install_libdir"; then
9277               break
9278             fi
9279             output="$output_objdir/$outputname"i
9280             # Replace all uninstalled libtool libraries with the installed ones
9281             newdependency_libs=
9282             for deplib in $dependency_libs; do
9283               case $deplib in
9284               *.la)
9285                 func_basename "$deplib"
9286                 name="$func_basename_result"
9287                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
9288                 test -z "$libdir" && \
9289                   func_fatal_error "\`$deplib' is not a valid libtool archive"
9290                 func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
9291                 ;;
9292               -L*)
9293                 func_stripname -L '' "$deplib"
9294                 func_replace_sysroot "$func_stripname_result"
9295                 func_append newdependency_libs " -L$func_replace_sysroot_result"
9296                 ;;
9297               -R*)
9298                 func_stripname -R '' "$deplib"
9299                 func_replace_sysroot "$func_stripname_result"
9300                 func_append newdependency_libs " -R$func_replace_sysroot_result"
9301                 ;;
9302               *) func_append newdependency_libs " $deplib" ;;
9303               esac
9304             done
9305             dependency_libs="$newdependency_libs"
9306             newdlfiles=
9307
9308             for lib in $dlfiles; do
9309               case $lib in
9310               *.la)
9311                 func_basename "$lib"
9312                 name="$func_basename_result"
9313                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9314                 test -z "$libdir" && \
9315                   func_fatal_error "\`$lib' is not a valid libtool archive"
9316                 func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
9317                 ;;
9318               *) func_append newdlfiles " $lib" ;;
9319               esac
9320             done
9321             dlfiles="$newdlfiles"
9322             newdlprefiles=
9323             for lib in $dlprefiles; do
9324               case $lib in
9325               *.la)
9326                 # Only pass preopened files to the pseudo-archive (for
9327                 # eventual linking with the app. that links it) if we
9328                 # didn't already link the preopened objects directly into
9329                 # the library:
9330                 func_basename "$lib"
9331                 name="$func_basename_result"
9332                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9333                 test -z "$libdir" && \
9334                   func_fatal_error "\`$lib' is not a valid libtool archive"
9335                 func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
9336                 ;;
9337               esac
9338             done
9339             dlprefiles="$newdlprefiles"
9340           else
9341             newdlfiles=
9342             for lib in $dlfiles; do
9343               case $lib in
9344                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9345                 *) abs=`pwd`"/$lib" ;;
9346               esac
9347               func_append newdlfiles " $abs"
9348             done
9349             dlfiles="$newdlfiles"
9350             newdlprefiles=
9351             for lib in $dlprefiles; do
9352               case $lib in
9353                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9354                 *) abs=`pwd`"/$lib" ;;
9355               esac
9356               func_append newdlprefiles " $abs"
9357             done
9358             dlprefiles="$newdlprefiles"
9359           fi
9360           $RM $output
9361           # place dlname in correct position for cygwin
9362           # In fact, it would be nice if we could use this code for all target
9363           # systems that can't hard-code library paths into their executables
9364           # and that have no shared library path variable independent of PATH,
9365           # but it turns out we can't easily determine that from inspecting
9366           # libtool variables, so we have to hard-code the OSs to which it
9367           # applies here; at the moment, that means platforms that use the PE
9368           # object format with DLL files.  See the long comment at the top of
9369           # tests/bindir.at for full details.
9370           tdlname=$dlname
9371           case $host,$output,$installed,$module,$dlname in
9372             *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
9373               # If a -bindir argument was supplied, place the dll there.
9374               if test "x$bindir" != x ;
9375               then
9376                 func_relative_path "$install_libdir" "$bindir"
9377                 tdlname=$func_relative_path_result$dlname
9378               else
9379                 # Otherwise fall back on heuristic.
9380                 tdlname=../bin/$dlname
9381               fi
9382               ;;
9383           esac
9384           $ECHO > $output "\
9385 # $outputname - a libtool library file
9386 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
9387 #
9388 # Please DO NOT delete this file!
9389 # It is necessary for linking the library.
9390
9391 # The name that we can dlopen(3).
9392 dlname='$tdlname'
9393
9394 # Names of this library.
9395 library_names='$library_names'
9396
9397 # The name of the static archive.
9398 old_library='$old_library'
9399
9400 # Linker flags that can not go in dependency_libs.
9401 inherited_linker_flags='$new_inherited_linker_flags'
9402
9403 # Libraries that this one depends upon.
9404 dependency_libs='$dependency_libs'
9405
9406 # Names of additional weak libraries provided by this library
9407 weak_library_names='$weak_libs'
9408
9409 # Version information for $libname.
9410 current=$current
9411 age=$age
9412 revision=$revision
9413
9414 # Is this an already installed library?
9415 installed=$installed
9416
9417 # Should we warn about portability when linking against -modules?
9418 shouldnotlink=$module
9419
9420 # Files to dlopen/dlpreopen
9421 dlopen='$dlfiles'
9422 dlpreopen='$dlprefiles'
9423
9424 # Directory that this library needs to be installed in:
9425 libdir='$install_libdir'"
9426           if test "$installed" = no && test "$need_relink" = yes; then
9427             $ECHO >> $output "\
9428 relink_command=\"$relink_command\""
9429           fi
9430         done
9431       }
9432
9433       # Do a symbolic link so that the libtool archive can be found in
9434       # LD_LIBRARY_PATH before the program is installed.
9435       func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
9436       ;;
9437     esac
9438     exit $EXIT_SUCCESS
9439 }
9440
9441 { test "$opt_mode" = link || test "$opt_mode" = relink; } &&
9442     func_mode_link ${1+"$@"}
9443
9444
9445 # func_mode_uninstall arg...
9446 func_mode_uninstall ()
9447 {
9448     $opt_debug
9449     RM="$nonopt"
9450     files=
9451     rmforce=
9452     exit_status=0
9453
9454     # This variable tells wrapper scripts just to set variables rather
9455     # than running their programs.
9456     libtool_install_magic="$magic"
9457
9458     for arg
9459     do
9460       case $arg in
9461       -f) func_append RM " $arg"; rmforce=yes ;;
9462       -*) func_append RM " $arg" ;;
9463       *) func_append files " $arg" ;;
9464       esac
9465     done
9466
9467     test -z "$RM" && \
9468       func_fatal_help "you must specify an RM program"
9469
9470     rmdirs=
9471
9472     for file in $files; do
9473       func_dirname "$file" "" "."
9474       dir="$func_dirname_result"
9475       if test "X$dir" = X.; then
9476         odir="$objdir"
9477       else
9478         odir="$dir/$objdir"
9479       fi
9480       func_basename "$file"
9481       name="$func_basename_result"
9482       test "$opt_mode" = uninstall && odir="$dir"
9483
9484       # Remember odir for removal later, being careful to avoid duplicates
9485       if test "$opt_mode" = clean; then
9486         case " $rmdirs " in
9487           *" $odir "*) ;;
9488           *) func_append rmdirs " $odir" ;;
9489         esac
9490       fi
9491
9492       # Don't error if the file doesn't exist and rm -f was used.
9493       if { test -L "$file"; } >/dev/null 2>&1 ||
9494          { test -h "$file"; } >/dev/null 2>&1 ||
9495          test -f "$file"; then
9496         :
9497       elif test -d "$file"; then
9498         exit_status=1
9499         continue
9500       elif test "$rmforce" = yes; then
9501         continue
9502       fi
9503
9504       rmfiles="$file"
9505
9506       case $name in
9507       *.la)
9508         # Possibly a libtool archive, so verify it.
9509         if func_lalib_p "$file"; then
9510           func_source $dir/$name
9511
9512           # Delete the libtool libraries and symlinks.
9513           for n in $library_names; do
9514             func_append rmfiles " $odir/$n"
9515           done
9516           test -n "$old_library" && func_append rmfiles " $odir/$old_library"
9517
9518           case "$opt_mode" in
9519           clean)
9520             case " $library_names " in
9521             *" $dlname "*) ;;
9522             *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
9523             esac
9524             test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
9525             ;;
9526           uninstall)
9527             if test -n "$library_names"; then
9528               # Do each command in the postuninstall commands.
9529               func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9530             fi
9531
9532             if test -n "$old_library"; then
9533               # Do each command in the old_postuninstall commands.
9534               func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9535             fi
9536             # FIXME: should reinstall the best remaining shared library.
9537             ;;
9538           esac
9539         fi
9540         ;;
9541
9542       *.lo)
9543         # Possibly a libtool object, so verify it.
9544         if func_lalib_p "$file"; then
9545
9546           # Read the .lo file
9547           func_source $dir/$name
9548
9549           # Add PIC object to the list of files to remove.
9550           if test -n "$pic_object" &&
9551              test "$pic_object" != none; then
9552             func_append rmfiles " $dir/$pic_object"
9553           fi
9554
9555           # Add non-PIC object to the list of files to remove.
9556           if test -n "$non_pic_object" &&
9557              test "$non_pic_object" != none; then
9558             func_append rmfiles " $dir/$non_pic_object"
9559           fi
9560         fi
9561         ;;
9562
9563       *)
9564         if test "$opt_mode" = clean ; then
9565           noexename=$name
9566           case $file in
9567           *.exe)
9568             func_stripname '' '.exe' "$file"
9569             file=$func_stripname_result
9570             func_stripname '' '.exe' "$name"
9571             noexename=$func_stripname_result
9572             # $file with .exe has already been added to rmfiles,
9573             # add $file without .exe
9574             func_append rmfiles " $file"
9575             ;;
9576           esac
9577           # Do a test to see if this is a libtool program.
9578           if func_ltwrapper_p "$file"; then
9579             if func_ltwrapper_executable_p "$file"; then
9580               func_ltwrapper_scriptname "$file"
9581               relink_command=
9582               func_source $func_ltwrapper_scriptname_result
9583               func_append rmfiles " $func_ltwrapper_scriptname_result"
9584             else
9585               relink_command=
9586               func_source $dir/$noexename
9587             fi
9588
9589             # note $name still contains .exe if it was in $file originally
9590             # as does the version of $file that was added into $rmfiles
9591             func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
9592             if test "$fast_install" = yes && test -n "$relink_command"; then
9593               func_append rmfiles " $odir/lt-$name"
9594             fi
9595             if test "X$noexename" != "X$name" ; then
9596               func_append rmfiles " $odir/lt-${noexename}.c"
9597             fi
9598           fi
9599         fi
9600         ;;
9601       esac
9602       func_show_eval "$RM $rmfiles" 'exit_status=1'
9603     done
9604
9605     # Try to remove the ${objdir}s in the directories where we deleted files
9606     for dir in $rmdirs; do
9607       if test -d "$dir"; then
9608         func_show_eval "rmdir $dir >/dev/null 2>&1"
9609       fi
9610     done
9611
9612     exit $exit_status
9613 }
9614
9615 { test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
9616     func_mode_uninstall ${1+"$@"}
9617
9618 test -z "$opt_mode" && {
9619   help="$generic_help"
9620   func_fatal_help "you must specify a MODE"
9621 }
9622
9623 test -z "$exec_cmd" && \
9624   func_fatal_help "invalid operation mode \`$opt_mode'"
9625
9626 if test -n "$exec_cmd"; then
9627   eval exec "$exec_cmd"
9628   exit $EXIT_FAILURE
9629 fi
9630
9631 exit $exit_status
9632
9633
9634 # The TAGs below are defined such that we never get into a situation
9635 # in which we disable both kinds of libraries.  Given conflicting
9636 # choices, we go for a static library, that is the most portable,
9637 # since we can't tell whether shared libraries were disabled because
9638 # the user asked for that or because the platform doesn't support
9639 # them.  This is particularly important on AIX, because we don't
9640 # support having both static and shared libraries enabled at the same
9641 # time on that platform, so we default to a shared-only configuration.
9642 # If a disable-shared tag is given, we'll fallback to a static-only
9643 # configuration.  But we'll never go from static-only to shared-only.
9644
9645 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
9646 build_libtool_libs=no
9647 build_old_libs=yes
9648 # ### END LIBTOOL TAG CONFIG: disable-shared
9649
9650 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
9651 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
9652 # ### END LIBTOOL TAG CONFIG: disable-static
9653
9654 # Local Variables:
9655 # mode:shell-script
9656 # sh-indentation:2
9657 # End:
9658 # vi:sw=2
9659