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