ltmain.sh

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