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 Debian-2.2.4-0ubuntu4
  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 Debian-2.2.4-0ubuntu4"
  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="/bin/grep -E"}
 120 : ${FGREP="/bin/grep -F"}
 121 : ${GREP="/bin/grep"}
 122 : ${LN_S="ln -s"}
 123 : ${MAKE="make"}
 124 : ${MKDIR="mkdir"}
 125 : ${MV="mv -f"}
 126 : ${RM="rm -f"}
 127 : ${SED="/bin/sed"}
 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,*)
4193         func_stripname '-Wl,' '' "$arg"
4194         args=$func_stripname_result
4195         arg=
4196         save_ifs="$IFS"; IFS=','
4197         for flag in $args; do
4198           IFS="$save_ifs"
4199           func_quote_for_eval "$flag"
4200           arg="$arg $wl$func_quote_for_eval_result"
4201           compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
4202           linker_flags="$linker_flags $func_quote_for_eval_result"
4203         done
4204         IFS="$save_ifs"
4205         func_stripname ' ' '' "$arg"
4206         arg=$func_stripname_result
4207         ;;
4208
4209       -Xcompiler)
4210         prev=xcompiler
4211         continue
4212         ;;
4213
4214       -Xlinker)
4215         prev=xlinker
4216         continue
4217         ;;
4218
4219       -XCClinker)
4220         prev=xcclinker
4221         continue
4222         ;;
4223
4224       # -msg_* for osf cc
4225       -msg_*)
4226         func_quote_for_eval "$arg"
4227         arg="$func_quote_for_eval_result"
4228         ;;
4229
4230       # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
4231       # -r[0-9][0-9]* specifies the processor on the SGI compiler
4232       # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
4233       # +DA*, +DD* enable 64-bit mode on the HP compiler
4234       # -q* pass through compiler args for the IBM compiler
4235       # -m*, -t[45]*, -txscale* pass through architecture-specific
4236       # compiler args for GCC
4237       # -F/path gives path to uninstalled frameworks, gcc on darwin
4238       # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
4239       # @file GCC response files
4240       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
4241       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
4242         func_quote_for_eval "$arg"
4243         arg="$func_quote_for_eval_result"
4244         func_append compile_command " $arg"
4245         func_append finalize_command " $arg"
4246         compiler_flags="$compiler_flags $arg"
4247         continue
4248         ;;
4249
4250       # Some other compiler flag.
4251       -* | +*)
4252         func_quote_for_eval "$arg"
4253         arg="$func_quote_for_eval_result"
4254         ;;
4255
4256       *.$objext)
4257         # A standard object.
4258         objs="$objs $arg"
4259         ;;
4260
4261       *.lo)
4262         # A libtool-controlled object.
4263
4264         # Check to see that this really is a libtool object.
4265         if func_lalib_unsafe_p "$arg"; then
4266           pic_object=
4267           non_pic_object=
4268
4269           # Read the .lo file
4270           func_source "$arg"
4271
4272           if test -z "$pic_object" ||
4273              test -z "$non_pic_object" ||
4274              test "$pic_object" = none &&
4275              test "$non_pic_object" = none; then
4276             func_fatal_error "cannot find name of object for \`$arg'"
4277           fi
4278
4279           # Extract subdirectory from the argument.
4280           func_dirname "$arg" "/" ""
4281           xdir="$func_dirname_result"
4282
4283           if test "$pic_object" != none; then
4284             # Prepend the subdirectory the object is found in.
4285             pic_object="$xdir$pic_object"
4286
4287             if test "$prev" = dlfiles; then
4288               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4289                 dlfiles="$dlfiles $pic_object"
4290                 prev=
4291                 continue
4292               else
4293                 # If libtool objects are unsupported, then we need to preload.
4294                 prev=dlprefiles
4295               fi
4296             fi
4297
4298             # CHECK ME:  I think I busted this.  -Ossama
4299             if test "$prev" = dlprefiles; then
4300               # Preload the old-style object.
4301               dlprefiles="$dlprefiles $pic_object"
4302               prev=
4303             fi
4304
4305             # A PIC object.
4306             func_append libobjs " $pic_object"
4307             arg="$pic_object"
4308           fi
4309
4310           # Non-PIC object.
4311           if test "$non_pic_object" != none; then
4312             # Prepend the subdirectory the object is found in.
4313             non_pic_object="$xdir$non_pic_object"
4314
4315             # A standard non-PIC object
4316             func_append non_pic_objects " $non_pic_object"
4317             if test -z "$pic_object" || test "$pic_object" = none ; then
4318               arg="$non_pic_object"
4319             fi
4320           else
4321             # If the PIC object exists, use it instead.
4322             # $xdir was prepended to $pic_object above.
4323             non_pic_object="$pic_object"
4324             func_append non_pic_objects " $non_pic_object"
4325           fi
4326         else
4327           # Only an error if not doing a dry-run.
4328           if $opt_dry_run; then
4329             # Extract subdirectory from the argument.
4330             func_dirname "$arg" "/" ""
4331             xdir="$func_dirname_result"
4332
4333             func_lo2o "$arg"
4334             pic_object=$xdir$objdir/$func_lo2o_result
4335             non_pic_object=$xdir$func_lo2o_result
4336             func_append libobjs " $pic_object"
4337             func_append non_pic_objects " $non_pic_object"
4338           else
4339             func_fatal_error "\`$arg' is not a valid libtool object"
4340           fi
4341         fi
4342         ;;
4343
4344       *.$libext)
4345         # An archive.
4346         deplibs="$deplibs $arg"
4347         old_deplibs="$old_deplibs $arg"
4348         continue
4349         ;;
4350
4351       *.la)
4352         # A libtool-controlled library.
4353
4354         if test "$prev" = dlfiles; then
4355           # This library was specified with -dlopen.
4356           dlfiles="$dlfiles $arg"
4357           prev=
4358         elif test "$prev" = dlprefiles; then
4359           # The library was specified with -dlpreopen.
4360           dlprefiles="$dlprefiles $arg"
4361           prev=
4362         else
4363           deplibs="$deplibs $arg"
4364         fi
4365         continue
4366         ;;
4367
4368       # Some other compiler argument.
4369       *)
4370         # Unknown arguments in both finalize_command and compile_command need
4371         # to be aesthetically quoted because they are evaled later.
4372         func_quote_for_eval "$arg"
4373         arg="$func_quote_for_eval_result"
4374         ;;
4375       esac # arg
4376
4377       # Now actually substitute the argument into the commands.
4378       if test -n "$arg"; then
4379         func_append compile_command " $arg"
4380         func_append finalize_command " $arg"
4381       fi
4382     done # argument parsing loop
4383
4384     test -n "$prev" && \
4385       func_fatal_help "the \`$prevarg' option requires an argument"
4386
4387     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
4388       eval arg=\"$export_dynamic_flag_spec\"
4389       func_append compile_command " $arg"
4390       func_append finalize_command " $arg"
4391     fi
4392
4393     oldlibs=
4394     # calculate the name of the file, without its directory
4395     func_basename "$output"
4396     outputname="$func_basename_result"
4397     libobjs_save="$libobjs"
4398
4399     if test -n "$shlibpath_var"; then
4400       # get the directories listed in $shlibpath_var
4401       eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
4402     else
4403       shlib_search_path=
4404     fi
4405     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
4406     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
4407
4408     func_dirname "$output" "/" ""
4409     output_objdir="$func_dirname_result$objdir"
4410     # Create the object directory.
4411     func_mkdir_p "$output_objdir"
4412
4413     # Determine the type of output
4414     case $output in
4415     "")
4416       func_fatal_help "you must specify an output file"
4417       ;;
4418     *.$libext) linkmode=oldlib ;;
4419     *.lo | *.$objext) linkmode=obj ;;
4420     *.la) linkmode=lib ;;
4421     *) linkmode=prog ;; # Anything else should be a program.
4422     esac
4423
4424     specialdeplibs=
4425
4426     libs=
4427     # Find all interdependent deplibs by searching for libraries
4428     # that are linked more than once (e.g. -la -lb -la)
4429     for deplib in $deplibs; do
4430       if $opt_duplicate_deps ; then
4431         case "$libs " in
4432         *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
4433         esac
4434       fi
4435       libs="$libs $deplib"
4436     done
4437
4438     if test "$linkmode" = lib; then
4439       libs="$predeps $libs $compiler_lib_search_path $postdeps"
4440
4441       # Compute libraries that are listed more than once in $predeps
4442       # $postdeps and mark them as special (i.e., whose duplicates are
4443       # not to be eliminated).
4444       pre_post_deps=
4445       if $opt_duplicate_compiler_generated_deps; then
4446         for pre_post_dep in $predeps $postdeps; do
4447           case "$pre_post_deps " in
4448           *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
4449           esac
4450           pre_post_deps="$pre_post_deps $pre_post_dep"
4451         done
4452       fi
4453       pre_post_deps=
4454     fi
4455
4456     deplibs=
4457     newdependency_libs=
4458     newlib_search_path=
4459     need_relink=no # whether we're linking any uninstalled libtool libraries
4460     notinst_deplibs= # not-installed libtool libraries
4461     notinst_path= # paths that contain not-installed libtool libraries
4462
4463     case $linkmode in
4464     lib)
4465         passes="conv dlpreopen link"
4466         for file in $dlfiles $dlprefiles; do
4467           case $file in
4468           *.la) ;;
4469           *)
4470             func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
4471             ;;
4472           esac
4473         done
4474         ;;
4475     prog)
4476         compile_deplibs=
4477         finalize_deplibs=
4478         alldeplibs=no
4479         newdlfiles=
4480         newdlprefiles=
4481         passes="conv scan dlopen dlpreopen link"
4482         ;;
4483     *)  passes="conv"
4484         ;;
4485     esac
4486
4487     for pass in $passes; do
4488       # The preopen pass in lib mode reverses $deplibs; put it back here
4489       # so that -L comes before libs that need it for instance...
4490       if test "$linkmode,$pass" = "lib,link"; then
4491         ## FIXME: Find the place where the list is rebuilt in the wrong
4492         ##        order, and fix it there properly
4493         tmp_deplibs=
4494         for deplib in $deplibs; do
4495           tmp_deplibs="$deplib $tmp_deplibs"
4496         done
4497         deplibs="$tmp_deplibs"
4498       fi
4499
4500       if test "$linkmode,$pass" = "lib,link" ||
4501          test "$linkmode,$pass" = "prog,scan"; then
4502         libs="$deplibs"
4503         deplibs=
4504       fi
4505       if test "$linkmode" = prog; then
4506         case $pass in
4507         dlopen) libs="$dlfiles" ;;
4508         dlpreopen) libs="$dlprefiles" ;;
4509         link)
4510           libs="$deplibs %DEPLIBS%"
4511           test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
4512           ;;
4513         esac
4514       fi
4515       if test "$linkmode,$pass" = "lib,dlpreopen"; then
4516         # Collect and forward deplibs of preopened libtool libs
4517         for lib in $dlprefiles; do
4518           # Ignore non-libtool-libs
4519           dependency_libs=
4520           case $lib in
4521           *.la) func_source "$lib" ;;
4522           esac
4523
4524           # Collect preopened libtool deplibs, except any this library
4525           # has declared as weak libs
4526           for deplib in $dependency_libs; do
4527             deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
4528             case " $weak_libs " in
4529             *" $deplib_base "*) ;;
4530             *) deplibs="$deplibs $deplib" ;;
4531             esac
4532           done
4533         done
4534         libs="$dlprefiles"
4535       fi
4536       if test "$pass" = dlopen; then
4537         # Collect dlpreopened libraries
4538         save_deplibs="$deplibs"
4539         deplibs=
4540       fi
4541
4542       for deplib in $libs; do
4543         lib=
4544         found=no
4545         case $deplib in
4546         -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4547           if test "$linkmode,$pass" = "prog,link"; then
4548             compile_deplibs="$deplib $compile_deplibs"
4549             finalize_deplibs="$deplib $finalize_deplibs"
4550           else
4551             compiler_flags="$compiler_flags $deplib"
4552             if test "$linkmode" = lib ; then
4553                 case "$new_inherited_linker_flags " in
4554                     *" $deplib "*) ;;
4555                     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
4556                 esac
4557             fi
4558           fi
4559           continue
4560           ;;
4561         -l*)
4562           if test "$linkmode" != lib && test "$linkmode" != prog; then
4563             func_warning "\`-l' is ignored for archives/objects"
4564             continue
4565           fi
4566           func_stripname '-l' '' "$deplib"
4567           name=$func_stripname_result
4568           if test "$linkmode" = lib; then
4569             searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
4570           else
4571             searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
4572           fi
4573           for searchdir in $searchdirs; do
4574             for search_ext in .la $std_shrext .so .a; do
4575               # Search the libtool library
4576               lib="$searchdir/lib${name}${search_ext}"
4577               if test -f "$lib"; then
4578                 if test "$search_ext" = ".la"; then
4579                   found=yes
4580                 else
4581                   found=no
4582                 fi
4583                 break 2
4584               fi
4585             done
4586           done
4587           if test "$found" != yes; then
4588             # deplib doesn't seem to be a libtool library
4589             if test "$linkmode,$pass" = "prog,link"; then
4590               compile_deplibs="$deplib $compile_deplibs"
4591               finalize_deplibs="$deplib $finalize_deplibs"
4592             else
4593               deplibs="$deplib $deplibs"
4594               test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
4595             fi
4596             continue
4597           else # deplib is a libtool library
4598             # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
4599             # We need to do some special things here, and not later.
4600             if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
4601               case " $predeps $postdeps " in
4602               *" $deplib "*)
4603                 if func_lalib_p "$lib"; then
4604                   library_names=
4605                   old_library=
4606                   func_source "$lib"
4607                   for l in $old_library $library_names; do
4608                     ll="$l"
4609                   done
4610                   if test "X$ll" = "X$old_library" ; then # only static version available
4611                     found=no
4612                     func_dirname "$lib" "" "."
4613                     ladir="$func_dirname_result"
4614                     lib=$ladir/$old_library
4615                     if test "$linkmode,$pass" = "prog,link"; then
4616                       compile_deplibs="$deplib $compile_deplibs"
4617                       finalize_deplibs="$deplib $finalize_deplibs"
4618                     else
4619                       deplibs="$deplib $deplibs"
4620                       test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
4621                     fi
4622                     continue
4623                   fi
4624                 fi
4625                 ;;
4626               *) ;;
4627               esac
4628             fi
4629           fi
4630           ;; # -l
4631         *.ltframework)
4632           if test "$linkmode,$pass" = "prog,link"; then
4633             compile_deplibs="$deplib $compile_deplibs"
4634             finalize_deplibs="$deplib $finalize_deplibs"
4635           else
4636             deplibs="$deplib $deplibs"
4637             if test "$linkmode" = lib ; then
4638                 case "$new_inherited_linker_flags " in
4639                     *" $deplib "*) ;;
4640                     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
4641                 esac
4642             fi
4643           fi
4644           continue
4645           ;;
4646         -L*)
4647           case $linkmode in
4648           lib)
4649             deplibs="$deplib $deplibs"
4650             test "$pass" = conv && continue
4651             newdependency_libs="$deplib $newdependency_libs"
4652             func_stripname '-L' '' "$deplib"
4653             newlib_search_path="$newlib_search_path $func_stripname_result"
4654             ;;
4655           prog)
4656             if test "$pass" = conv; then
4657               deplibs="$deplib $deplibs"
4658               continue
4659             fi
4660             if test "$pass" = scan; then
4661               deplibs="$deplib $deplibs"
4662             else
4663               compile_deplibs="$deplib $compile_deplibs"
4664               finalize_deplibs="$deplib $finalize_deplibs"
4665             fi
4666             func_stripname '-L' '' "$deplib"
4667             newlib_search_path="$newlib_search_path $func_stripname_result"
4668             ;;
4669           *)
4670             func_warning "\`-L' is ignored for archives/objects"
4671             ;;
4672           esac # linkmode
4673           continue
4674           ;; # -L
4675         -R*)
4676           if test "$pass" = link; then
4677             func_stripname '-R' '' "$deplib"
4678             dir=$func_stripname_result
4679             # Make sure the xrpath contains only unique directories.
4680             case "$xrpath " in
4681             *" $dir "*) ;;
4682             *) xrpath="$xrpath $dir" ;;
4683             esac
4684           fi
4685           deplibs="$deplib $deplibs"
4686           continue
4687           ;;
4688         *.la) lib="$deplib" ;;
4689         *.$libext)
4690           if test "$pass" = conv; then
4691             deplibs="$deplib $deplibs"
4692             continue
4693           fi
4694           case $linkmode in
4695           lib)
4696             # Linking convenience modules into shared libraries is allowed,
4697             # but linking other static libraries is non-portable.
4698             case " $dlpreconveniencelibs " in
4699             *" $deplib "*) ;;
4700             *)
4701               valid_a_lib=no
4702               case $deplibs_check_method in
4703                 match_pattern*)
4704                   set dummy $deplibs_check_method; shift
4705                   match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
4706                   if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
4707                     | $EGREP "$match_pattern_regex" > /dev/null; then
4708                     valid_a_lib=yes
4709                   fi
4710                 ;;
4711                 pass_all)
4712                   valid_a_lib=yes
4713                 ;;
4714               esac
4715               if test "$valid_a_lib" != yes; then
4716                 $ECHO
4717                 $ECHO "*** Warning: Trying to link with static lib archive $deplib."
4718                 $ECHO "*** I have the capability to make that library automatically link in when"
4719                 $ECHO "*** you link to this library.  But I can only do this if you have a"
4720                 $ECHO "*** shared version of the library, which you do not appear to have"
4721                 $ECHO "*** because the file extensions .$libext of this argument makes me believe"
4722                 $ECHO "*** that it is just a static archive that I should not use here."
4723               else
4724                 $ECHO
4725                 $ECHO "*** Warning: Linking the shared library $output against the"
4726                 $ECHO "*** static library $deplib is not portable!"
4727                 deplibs="$deplib $deplibs"
4728               fi
4729               ;;
4730             esac
4731             continue
4732             ;;
4733           prog)
4734             if test "$pass" != link; then
4735               deplibs="$deplib $deplibs"
4736             else
4737               compile_deplibs="$deplib $compile_deplibs"
4738               finalize_deplibs="$deplib $finalize_deplibs"
4739             fi
4740             continue
4741             ;;
4742           esac # linkmode
4743           ;; # *.$libext
4744         *.lo | *.$objext)
4745           if test "$pass" = conv; then
4746             deplibs="$deplib $deplibs"
4747           elif test "$linkmode" = prog; then
4748             if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
4749               # If there is no dlopen support or we're linking statically,
4750               # we need to preload.
4751               newdlprefiles="$newdlprefiles $deplib"
4752               compile_deplibs="$deplib $compile_deplibs"
4753               finalize_deplibs="$deplib $finalize_deplibs"
4754             else
4755               newdlfiles="$newdlfiles $deplib"
4756             fi
4757           fi
4758           continue
4759           ;;
4760         %DEPLIBS%)
4761           alldeplibs=yes
4762           continue
4763           ;;
4764         esac # case $deplib
4765
4766         if test "$found" = yes || test -f "$lib"; then :
4767         else
4768           func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
4769         fi
4770
4771         # Check to see that this really is a libtool archive.
4772         func_lalib_unsafe_p "$lib" \
4773           || func_fatal_error "\`$lib' is not a valid libtool archive"
4774
4775         func_dirname "$lib" "" "."
4776         ladir="$func_dirname_result"
4777
4778         dlname=
4779         dlopen=
4780         dlpreopen=
4781         libdir=
4782         library_names=
4783         old_library=
4784         inherited_linker_flags=
4785         # If the library was installed with an old release of libtool,
4786         # it will not redefine variables installed, or shouldnotlink
4787         installed=yes
4788         shouldnotlink=no
4789         avoidtemprpath=
4790
4791
4792         # Read the .la file
4793         func_source "$lib"
4794
4795         # Convert "-framework foo" to "foo.ltframework"
4796         if test -n "$inherited_linker_flags"; then
4797           tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
4798           for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
4799             case " $new_inherited_linker_flags " in
4800               *" $tmp_inherited_linker_flag "*) ;;
4801               *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
4802             esac
4803           done
4804         fi
4805         dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
4806         if test "$linkmode,$pass" = "lib,link" ||
4807            test "$linkmode,$pass" = "prog,scan" ||
4808            { test "$linkmode" != prog && test "$linkmode" != lib; }; then
4809           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
4810           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
4811         fi
4812
4813         if test "$pass" = conv; then
4814           # Only check for convenience libraries
4815           deplibs="$lib $deplibs"
4816           if test -z "$libdir"; then
4817             if test -z "$old_library"; then
4818               func_fatal_error "cannot find name of link library for \`$lib'"
4819             fi
4820             # It is a libtool convenience library, so add in its objects.
4821             convenience="$convenience $ladir/$objdir/$old_library"
4822             old_convenience="$old_convenience $ladir/$objdir/$old_library"
4823           elif test "$linkmode" != prog && test "$linkmode" != lib; then
4824             func_fatal_error "\`$lib' is not a convenience library"
4825           fi
4826           tmp_libs=
4827           for deplib in $dependency_libs; do
4828             deplibs="$deplib $deplibs"
4829             if $opt_duplicate_deps ; then
4830               case "$tmp_libs " in
4831               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
4832               esac
4833             fi
4834             tmp_libs="$tmp_libs $deplib"
4835           done
4836           continue
4837         fi # $pass = conv
4838
4839
4840         # Get the name of the library we link against.
4841         linklib=
4842         for l in $old_library $library_names; do
4843           linklib="$l"
4844         done
4845         if test -z "$linklib"; then
4846           func_fatal_error "cannot find name of link library for \`$lib'"
4847         fi
4848
4849         # This library was specified with -dlopen.
4850         if test "$pass" = dlopen; then
4851           if test -z "$libdir"; then
4852             func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
4853           fi
4854           if test -z "$dlname" ||
4855              test "$dlopen_support" != yes ||
4856              test "$build_libtool_libs" = no; then
4857             # If there is no dlname, no dlopen support or we're linking
4858             # statically, we need to preload.  We also need to preload any
4859             # dependent libraries so libltdl's deplib preloader doesn't
4860             # bomb out in the load deplibs phase.
4861             dlprefiles="$dlprefiles $lib $dependency_libs"
4862           else
4863             newdlfiles="$newdlfiles $lib"
4864           fi
4865           continue
4866         fi # $pass = dlopen
4867
4868         # We need an absolute path.
4869         case $ladir in
4870         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
4871         *)
4872           abs_ladir=`cd "$ladir" && pwd`
4873           if test -z "$abs_ladir"; then
4874             func_warning "cannot determine absolute directory name of \`$ladir'"
4875             func_warning "passing it literally to the linker, although it might fail"
4876             abs_ladir="$ladir"
4877           fi
4878           ;;
4879         esac
4880         func_basename "$lib"
4881         laname="$func_basename_result"
4882
4883         # Find the relevant object directory and library name.
4884         if test "X$installed" = Xyes; then
4885           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
4886             func_warning "library \`$lib' was moved."
4887             dir="$ladir"
4888             absdir="$abs_ladir"
4889             libdir="$abs_ladir"
4890           else
4891             dir="$libdir"
4892             absdir="$libdir"
4893           fi
4894           test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
4895         else
4896           if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
4897             dir="$ladir"
4898             absdir="$abs_ladir"
4899             # Remove this search path later
4900             notinst_path="$notinst_path $abs_ladir"
4901           else
4902             dir="$ladir/$objdir"
4903             absdir="$abs_ladir/$objdir"
4904             # Remove this search path later
4905             notinst_path="$notinst_path $abs_ladir"
4906           fi
4907         fi # $installed = yes
4908         func_stripname 'lib' '.la' "$laname"
4909         name=$func_stripname_result
4910
4911         # This library was specified with -dlpreopen.
4912         if test "$pass" = dlpreopen; then
4913           if test -z "$libdir" && test "$linkmode" = prog; then
4914             func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
4915           fi
4916           # Prefer using a static library (so that no silly _DYNAMIC symbols
4917           # are required to link).
4918           if test -n "$old_library"; then
4919             newdlprefiles="$newdlprefiles $dir/$old_library"
4920             # Keep a list of preopened convenience libraries to check
4921             # that they are being used correctly in the link pass.
4922             test -z "$libdir" && \
4923                 dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
4924           # Otherwise, use the dlname, so that lt_dlopen finds it.
4925           elif test -n "$dlname"; then
4926             newdlprefiles="$newdlprefiles $dir/$dlname"
4927           else
4928             newdlprefiles="$newdlprefiles $dir/$linklib"
4929           fi
4930         fi # $pass = dlpreopen
4931
4932         if test -z "$libdir"; then
4933           # Link the convenience library
4934           if test "$linkmode" = lib; then
4935             deplibs="$dir/$old_library $deplibs"
4936           elif test "$linkmode,$pass" = "prog,link"; then
4937             compile_deplibs="$dir/$old_library $compile_deplibs"
4938             finalize_deplibs="$dir/$old_library $finalize_deplibs"
4939           else
4940             deplibs="$lib $deplibs" # used for prog,scan pass
4941           fi
4942           continue
4943         fi
4944
4945
4946         if test "$linkmode" = prog && test "$pass" != link; then
4947           newlib_search_path="$newlib_search_path $ladir"
4948           deplibs="$lib $deplibs"
4949
4950           linkalldeplibs=no
4951           if test "$link_all_deplibs" != no || test -z "$library_names" ||
4952              test "$build_libtool_libs" = no; then
4953             linkalldeplibs=yes
4954           fi
4955
4956           tmp_libs=
4957           for deplib in $dependency_libs; do
4958             case $deplib in
4959             -L*) func_stripname '-L' '' "$deplib"
4960                  newlib_search_path="$newlib_search_path $func_stripname_result"
4961                  ;;
4962             esac
4963             # Need to link against all dependency_libs?
4964             if test "$linkalldeplibs" = yes; then
4965               deplibs="$deplib $deplibs"
4966             else
4967               # Need to hardcode shared library paths
4968               # or/and link against static libraries
4969               newdependency_libs="$deplib $newdependency_libs"
4970             fi
4971             if $opt_duplicate_deps ; then
4972               case "$tmp_libs " in
4973               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
4974               esac
4975             fi
4976             tmp_libs="$tmp_libs $deplib"
4977           done # for deplib
4978           continue
4979         fi # $linkmode = prog...
4980
4981         if test "$linkmode,$pass" = "prog,link"; then
4982           if test -n "$library_names" &&
4983              { { test "$prefer_static_libs" = no ||
4984                  test "$prefer_static_libs,$installed" = "built,yes"; } ||
4985                test -z "$old_library"; }; then
4986             # We need to hardcode the library path
4987             if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
4988               # Make sure the rpath contains only unique directories.
4989               case "$temp_rpath:" in
4990               *"$absdir:"*) ;;
4991               *) temp_rpath="$temp_rpath$absdir:" ;;
4992               esac
4993             fi
4994
4995             # Hardcode the library path.
4996             # Skip directories that are in the system default run-time
4997             # search path.
4998             case " $sys_lib_dlsearch_path " in
4999             *" $absdir "*) ;;
5000             *)
5001               case "$compile_rpath " in
5002               *" $absdir "*) ;;
5003               *) compile_rpath="$compile_rpath $absdir"
5004               esac
5005               ;;
5006             esac
5007             case " $sys_lib_dlsearch_path " in
5008             *" $libdir "*) ;;
5009             *)
5010               case "$finalize_rpath " in
5011               *" $libdir "*) ;;
5012               *) finalize_rpath="$finalize_rpath $libdir"
5013               esac
5014               ;;
5015             esac
5016           fi # $linkmode,$pass = prog,link...
5017
5018           if test "$alldeplibs" = yes &&
5019              { test "$deplibs_check_method" = pass_all ||
5020                { test "$build_libtool_libs" = yes &&
5021                  test -n "$library_names"; }; }; then
5022             # We only need to search for static libraries
5023             continue
5024           fi
5025         fi
5026
5027         link_static=no # Whether the deplib will be linked statically
5028         use_static_libs=$prefer_static_libs
5029         if test "$use_static_libs" = built && test "$installed" = yes; then
5030           use_static_libs=no
5031         fi
5032         if test -n "$library_names" &&
5033            { test "$use_static_libs" = no || test -z "$old_library"; }; then
5034           case $host in
5035           *cygwin* | *mingw*)
5036               # No point in relinking DLLs because paths are not encoded
5037               notinst_deplibs="$notinst_deplibs $lib"
5038               need_relink=no
5039             ;;
5040           *)
5041             if test "$installed" = no; then
5042               notinst_deplibs="$notinst_deplibs $lib"
5043               need_relink=yes
5044             fi
5045             ;;
5046           esac
5047           # This is a shared library
5048
5049           # Warn about portability, can't link against -module's on some
5050           # systems (darwin).  Don't bleat about dlopened modules though!
5051           dlopenmodule=""
5052           for dlpremoduletest in $dlprefiles; do
5053             if test "X$dlpremoduletest" = "X$lib"; then
5054               dlopenmodule="$dlpremoduletest"
5055               break
5056             fi
5057           done
5058           if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
5059             $ECHO
5060             if test "$linkmode" = prog; then
5061               $ECHO "*** Warning: Linking the executable $output against the loadable module"
5062             else
5063               $ECHO "*** Warning: Linking the shared library $output against the loadable module"
5064             fi
5065             $ECHO "*** $linklib is not portable!"
5066           fi
5067           if test "$linkmode" = lib &&
5068              test "$hardcode_into_libs" = yes; then
5069             # Hardcode the library path.
5070             # Skip directories that are in the system default run-time
5071             # search path.
5072             case " $sys_lib_dlsearch_path " in
5073             *" $absdir "*) ;;
5074             *)
5075               case "$compile_rpath " in
5076               *" $absdir "*) ;;
5077               *) compile_rpath="$compile_rpath $absdir"
5078               esac
5079               ;;
5080             esac
5081             case " $sys_lib_dlsearch_path " in
5082             *" $libdir "*) ;;
5083             *)
5084               case "$finalize_rpath " in
5085               *" $libdir "*) ;;
5086               *) finalize_rpath="$finalize_rpath $libdir"
5087               esac
5088               ;;
5089             esac
5090           fi
5091
5092           if test -n "$old_archive_from_expsyms_cmds"; then
5093             # figure out the soname
5094             set dummy $library_names
5095             shift
5096             realname="$1"
5097             shift
5098             libname=`eval "\\$ECHO \"$libname_spec\""`
5099             # use dlname if we got it. it's perfectly good, no?
5100             if test -n "$dlname"; then
5101               soname="$dlname"
5102             elif test -n "$soname_spec"; then
5103               # bleh windows
5104               case $host in
5105               *cygwin* | mingw*)
5106                 func_arith $current - $age
5107                 major=$func_arith_result
5108                 versuffix="-$major"
5109                 ;;
5110               esac
5111               eval soname=\"$soname_spec\"
5112             else
5113               soname="$realname"
5114             fi
5115
5116             # Make a new name for the extract_expsyms_cmds to use
5117             soroot="$soname"
5118             func_basename "$soroot"
5119             soname="$func_basename_result"
5120             func_stripname 'lib' '.dll' "$soname"
5121             newlib=libimp-$func_stripname_result.a
5122
5123             # If the library has no export list, then create one now
5124             if test -f "$output_objdir/$soname-def"; then :
5125             else
5126               func_verbose "extracting exported symbol list from \`$soname'"
5127               func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
5128             fi
5129
5130             # Create $newlib
5131             if test -f "$output_objdir/$newlib"; then :; else
5132               func_verbose "generating import library for \`$soname'"
5133               func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
5134             fi
5135             # make sure the library variables are pointing to the new library
5136             dir=$output_objdir
5137             linklib=$newlib
5138           fi # test -n "$old_archive_from_expsyms_cmds"
5139
5140           if test "$linkmode" = prog || test "$mode" != relink; then
5141             add_shlibpath=
5142             add_dir=
5143             add=
5144             lib_linked=yes
5145             case $hardcode_action in
5146             immediate | unsupported)
5147               if test "$hardcode_direct" = no; then
5148                 add="$dir/$linklib"
5149                 case $host in
5150                   *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
5151                   *-*-sysv4*uw2*) add_dir="-L$dir" ;;
5152                   *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
5153                     *-*-unixware7*) add_dir="-L$dir" ;;
5154                   *-*-darwin* )
5155                     # if the lib is a (non-dlopened) module then we can not
5156                     # link against it, someone is ignoring the earlier warnings
5157                     if /usr/bin/file -L $add 2> /dev/null |
5158                          $GREP ": [^:]* bundle" >/dev/null ; then
5159                       if test "X$dlopenmodule" != "X$lib"; then
5160                         $ECHO "*** Warning: lib $linklib is a module, not a shared library"
5161                         if test -z "$old_library" ; then
5162                           $ECHO
5163                           $ECHO "*** And there doesn't seem to be a static archive available"
5164                           $ECHO "*** The link will probably fail, sorry"
5165                         else
5166                           add="$dir/$old_library"
5167                         fi
5168                       elif test -n "$old_library"; then
5169                         add="$dir/$old_library"
5170                       fi
5171                     fi
5172                 esac
5173               elif test "$hardcode_minus_L" = no; then
5174                 case $host in
5175                 *-*-sunos*) add_shlibpath="$dir" ;;
5176                 esac
5177                 add_dir="-L$dir"
5178                 add="-l$name"
5179               elif test "$hardcode_shlibpath_var" = no; then
5180                 add_shlibpath="$dir"
5181                 add="-l$name"
5182               else
5183                 lib_linked=no
5184               fi
5185               ;;
5186             relink)
5187               if test "$hardcode_direct" = yes &&
5188                  test "$hardcode_direct_absolute" = no; then
5189                 add="$dir/$linklib"
5190               elif test "$hardcode_minus_L" = yes; then
5191                 add_dir="-L$dir"
5192                 # Try looking first in the location we're being installed to.
5193                 if test -n "$inst_prefix_dir"; then
5194                   case $libdir in
5195                     [\\/]*)
5196                       add_dir="$add_dir -L$inst_prefix_dir$libdir"
5197                       ;;
5198                   esac
5199                 fi
5200                 add="-l$name"
5201               elif test "$hardcode_shlibpath_var" = yes; then
5202                 add_shlibpath="$dir"
5203                 add="-l$name"
5204               else
5205                 lib_linked=no
5206               fi
5207               ;;
5208             *) lib_linked=no ;;
5209             esac
5210
5211             if test "$lib_linked" != yes; then
5212               func_fatal_configuration "unsupported hardcode properties"
5213             fi
5214
5215             if test -n "$add_shlibpath"; then
5216               case :$compile_shlibpath: in
5217               *":$add_shlibpath:"*) ;;
5218               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
5219               esac
5220             fi
5221             if test "$linkmode" = prog; then
5222               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
5223               test -n "$add" && compile_deplibs="$add $compile_deplibs"
5224             else
5225               test -n "$add_dir" && deplibs="$add_dir $deplibs"
5226               test -n "$add" && deplibs="$add $deplibs"
5227               if test "$hardcode_direct" != yes &&
5228                  test "$hardcode_minus_L" != yes &&
5229                  test "$hardcode_shlibpath_var" = yes; then
5230                 case :$finalize_shlibpath: in
5231                 *":$libdir:"*) ;;
5232                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5233                 esac
5234               fi
5235             fi
5236           fi
5237
5238           if test "$linkmode" = prog || test "$mode" = relink; then
5239             add_shlibpath=
5240             add_dir=
5241             add=
5242             # Finalize command for both is simple: just hardcode it.
5243             if test "$hardcode_direct" = yes &&
5244                test "$hardcode_direct_absolute" = no; then
5245               add="$libdir/$linklib"
5246             elif test "$hardcode_minus_L" = yes; then
5247               add_dir="-L$libdir"
5248               add="-l$name"
5249             elif test "$hardcode_shlibpath_var" = yes; then
5250               case :$finalize_shlibpath: in
5251               *":$libdir:"*) ;;
5252               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5253               esac
5254               add="-l$name"
5255             elif test "$hardcode_automatic" = yes; then
5256               if test -n "$inst_prefix_dir" &&
5257                  test -f "$inst_prefix_dir$libdir/$linklib" ; then
5258                 add="$inst_prefix_dir$libdir/$linklib"
5259               else
5260                 add="$libdir/$linklib"
5261               fi
5262             else
5263               # We cannot seem to hardcode it, guess we'll fake it.
5264               add_dir="-L$libdir"
5265               # Try looking first in the location we're being installed to.
5266               if test -n "$inst_prefix_dir"; then
5267                 case $libdir in
5268                   [\\/]*)
5269                     add_dir="$add_dir -L$inst_prefix_dir$libdir"
5270                     ;;
5271                 esac
5272               fi
5273               add="-l$name"
5274             fi
5275
5276             if test "$linkmode" = prog; then
5277               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
5278               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
5279             else
5280               test -n "$add_dir" && deplibs="$add_dir $deplibs"
5281               test -n "$add" && deplibs="$add $deplibs"
5282             fi
5283           fi
5284         elif test "$linkmode" = prog; then
5285           # Here we assume that one of hardcode_direct or hardcode_minus_L
5286           # is not unsupported.  This is valid on all known static and
5287           # shared platforms.
5288           if test "$hardcode_direct" != unsupported; then
5289             test -n "$old_library" && linklib="$old_library"
5290             compile_deplibs="$dir/$linklib $compile_deplibs"
5291             finalize_deplibs="$dir/$linklib $finalize_deplibs"
5292           else
5293             compile_deplibs="-l$name -L$dir $compile_deplibs"
5294             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
5295           fi
5296         elif test "$build_libtool_libs" = yes; then
5297           # Not a shared library
5298           if test "$deplibs_check_method" != pass_all; then
5299             # We're trying link a shared library against a static one
5300             # but the system doesn't support it.
5301
5302             # Just print a warning and add the library to dependency_libs so
5303             # that the program can be linked against the static library.
5304             $ECHO
5305             $ECHO "*** Warning: This system can not link to static lib archive $lib."
5306             $ECHO "*** I have the capability to make that library automatically link in when"
5307             $ECHO "*** you link to this library.  But I can only do this if you have a"
5308             $ECHO "*** shared version of the library, which you do not appear to have."
5309             if test "$module" = yes; then
5310               $ECHO "*** But as you try to build a module library, libtool will still create "
5311               $ECHO "*** a static module, that should work as long as the dlopening application"
5312               $ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
5313               if test -z "$global_symbol_pipe"; then
5314                 $ECHO
5315                 $ECHO "*** However, this would only work if libtool was able to extract symbol"
5316                 $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
5317                 $ECHO "*** not find such a program.  So, this module is probably useless."
5318                 $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
5319               fi
5320               if test "$build_old_libs" = no; then
5321                 build_libtool_libs=module
5322                 build_old_libs=yes
5323               else
5324                 build_libtool_libs=no
5325               fi
5326             fi
5327           else
5328             deplibs="$dir/$old_library $deplibs"
5329             link_static=yes
5330           fi
5331         fi # link shared/static library?
5332
5333         if test "$linkmode" = lib; then
5334           if test -n "$dependency_libs" &&
5335              { test "$hardcode_into_libs" != yes ||
5336                test "$build_old_libs" = yes ||
5337                test "$link_static" = yes; }; then
5338             # Extract -R from dependency_libs
5339             temp_deplibs=
5340             for libdir in $dependency_libs; do
5341               case $libdir in
5342               -R*) func_stripname '-R' '' "$libdir"
5343                    temp_xrpath=$func_stripname_result
5344                    case " $xrpath " in
5345                    *" $temp_xrpath "*) ;;
5346                    *) xrpath="$xrpath $temp_xrpath";;
5347                    esac;;
5348               *) temp_deplibs="$temp_deplibs $libdir";;
5349               esac
5350             done
5351             dependency_libs="$temp_deplibs"
5352           fi
5353
5354           newlib_search_path="$newlib_search_path $absdir"
5355           # Link against this library
5356           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
5357           # ... and its dependency_libs
5358           tmp_libs=
5359           for deplib in $dependency_libs; do
5360             newdependency_libs="$deplib $newdependency_libs"
5361             if $opt_duplicate_deps ; then
5362               case "$tmp_libs " in
5363               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5364               esac
5365             fi
5366             tmp_libs="$tmp_libs $deplib"
5367           done
5368
5369           if test "$link_all_deplibs" != no; then
5370             # Add the search paths of all dependency libraries
5371             for deplib in $dependency_libs; do
5372               case $deplib in
5373               -L*) path="$deplib" ;;
5374               *.la)
5375                 func_dirname "$deplib" "" "."
5376                 dir="$func_dirname_result"
5377                 # We need an absolute path.
5378                 case $dir in
5379                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
5380                 *)
5381                   absdir=`cd "$dir" && pwd`
5382                   if test -z "$absdir"; then
5383                     func_warning "cannot determine absolute directory name of \`$dir'"
5384                     absdir="$dir"
5385                   fi
5386                   ;;
5387                 esac
5388                 if $GREP "^installed=no" $deplib > /dev/null; then
5389                 case $host in
5390                 *-*-darwin*)
5391                   depdepl=
5392                   eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
5393                   if test -n "$deplibrary_names" ; then
5394                     for tmp in $deplibrary_names ; do
5395                       depdepl=$tmp
5396                     done
5397                     if test -f "$absdir/$objdir/$depdepl" ; then
5398                       depdepl="$absdir/$objdir/$depdepl"
5399                       darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
5400                       if test -z "$darwin_install_name"; then
5401                           darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
5402                       fi
5403                       compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
5404                       linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
5405                       path=
5406                     fi
5407                   fi
5408                   ;;
5409                 *)
5410                   path="-L$absdir/$objdir"
5411                   ;;
5412                 esac
5413                 else
5414                   eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5415                   test -z "$libdir" && \
5416                     func_fatal_error "\`$deplib' is not a valid libtool archive"
5417                   test "$absdir" != "$libdir" && \
5418                     func_warning "\`$deplib' seems to be moved"
5419
5420                   path="-L$absdir"
5421                 fi
5422                 ;;
5423               esac
5424               case " $deplibs " in
5425               *" $path "*) ;;
5426               *) deplibs="$path $deplibs" ;;
5427               esac
5428             done
5429           fi # link_all_deplibs != no
5430         fi # linkmode = lib
5431       done # for deplib in $libs
5432       if test "$pass" = link; then
5433         if test "$linkmode" = "prog"; then
5434           compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
5435           finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
5436         else
5437           compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5438         fi
5439       fi
5440       dependency_libs="$newdependency_libs"
5441       if test "$pass" = dlpreopen; then
5442         # Link the dlpreopened libraries before other libraries
5443         for deplib in $save_deplibs; do
5444           deplibs="$deplib $deplibs"
5445         done
5446       fi
5447       if test "$pass" != dlopen; then
5448         if test "$pass" != conv; then
5449           # Make sure lib_search_path contains only unique directories.
5450           lib_search_path=
5451           for dir in $newlib_search_path; do
5452             case "$lib_search_path " in
5453             *" $dir "*) ;;
5454             *) lib_search_path="$lib_search_path $dir" ;;
5455             esac
5456           done
5457           newlib_search_path=
5458         fi
5459
5460         if test "$linkmode,$pass" != "prog,link"; then
5461           vars="deplibs"
5462         else
5463           vars="compile_deplibs finalize_deplibs"
5464         fi
5465         for var in $vars dependency_libs; do
5466           # Add libraries to $var in reverse order
5467           eval tmp_libs=\"\$$var\"
5468           new_libs=
5469           for deplib in $tmp_libs; do
5470             # FIXME: Pedantically, this is the right thing to do, so
5471             #        that some nasty dependency loop isn't accidentally
5472             #        broken:
5473             #new_libs="$deplib $new_libs"
5474             # Pragmatically, this seems to cause very few problems in
5475             # practice:
5476             case $deplib in
5477             -L*) new_libs="$deplib $new_libs" ;;
5478             -R*) ;;
5479             *)
5480               # And here is the reason: when a library appears more
5481               # than once as an explicit dependence of a library, or
5482               # is implicitly linked in more than once by the
5483               # compiler, it is considered special, and multiple
5484               # occurrences thereof are not removed.  Compare this
5485               # with having the same library being listed as a
5486               # dependency of multiple other libraries: in this case,
5487               # we know (pedantically, we assume) the library does not
5488               # need to be listed more than once, so we keep only the
5489               # last copy.  This is not always right, but it is rare
5490               # enough that we require users that really mean to play
5491               # such unportable linking tricks to link the library
5492               # using -Wl,-lname, so that libtool does not consider it
5493               # for duplicate removal.
5494               case " $specialdeplibs " in
5495               *" $deplib "*) new_libs="$deplib $new_libs" ;;
5496               *)
5497                 case " $new_libs " in
5498                 *" $deplib "*) ;;
5499                 *) new_libs="$deplib $new_libs" ;;
5500                 esac
5501                 ;;
5502               esac
5503               ;;
5504             esac
5505           done
5506           tmp_libs=
5507           for deplib in $new_libs; do
5508             case $deplib in
5509             -L*)
5510               case " $tmp_libs " in
5511               *" $deplib "*) ;;
5512               *) tmp_libs="$tmp_libs $deplib" ;;
5513               esac
5514               ;;
5515             *) tmp_libs="$tmp_libs $deplib" ;;
5516             esac
5517           done
5518           eval $var=\"$tmp_libs\"
5519         done # for var
5520       fi
5521       # Last step: remove runtime libs from dependency_libs
5522       # (they stay in deplibs)
5523       tmp_libs=
5524       for i in $dependency_libs ; do
5525         case " $predeps $postdeps $compiler_lib_search_path " in
5526         *" $i "*)
5527           i=""
5528           ;;
5529         esac
5530         if test -n "$i" ; then
5531           tmp_libs="$tmp_libs $i"
5532         fi
5533       done
5534       dependency_libs=$tmp_libs
5535     done # for pass
5536     if test "$linkmode" = prog; then
5537       dlfiles="$newdlfiles"
5538     fi
5539     if test "$linkmode" = prog || test "$linkmode" = lib; then
5540       dlprefiles="$newdlprefiles"
5541     fi
5542
5543     case $linkmode in
5544     oldlib)
5545       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
5546         func_warning "\`-dlopen' is ignored for archives"
5547       fi
5548
5549       case " $deplibs" in
5550       *\ -l* | *\ -L*)
5551         func_warning "\`-l' and \`-L' are ignored for archives" ;;
5552       esac
5553
5554       test -n "$rpath" && \
5555         func_warning "\`-rpath' is ignored for archives"
5556
5557       test -n "$xrpath" && \
5558         func_warning "\`-R' is ignored for archives"
5559
5560       test -n "$vinfo" && \
5561         func_warning "\`-version-info/-version-number' is ignored for archives"
5562
5563       test -n "$release" && \
5564         func_warning "\`-release' is ignored for archives"
5565
5566       test -n "$export_symbols$export_symbols_regex" && \
5567         func_warning "\`-export-symbols' is ignored for archives"
5568
5569       # Now set the variables for building old libraries.
5570       build_libtool_libs=no
5571       oldlibs="$output"
5572       objs="$objs$old_deplibs"
5573       ;;
5574
5575     lib)
5576       # Make sure we only generate libraries of the form `libNAME.la'.
5577       case $outputname in
5578       lib*)
5579         func_stripname 'lib' '.la' "$outputname"
5580         name=$func_stripname_result
5581         eval shared_ext=\"$shrext_cmds\"
5582         eval libname=\"$libname_spec\"
5583         ;;
5584       *)
5585         test "$module" = no && \
5586           func_fatal_help "libtool library \`$output' must begin with \`lib'"
5587
5588         if test "$need_lib_prefix" != no; then
5589           # Add the "lib" prefix for modules if required
5590           func_stripname '' '.la' "$outputname"
5591           name=$func_stripname_result
5592           eval shared_ext=\"$shrext_cmds\"
5593           eval libname=\"$libname_spec\"
5594         else
5595           func_stripname '' '.la' "$outputname"
5596           libname=$func_stripname_result
5597         fi
5598         ;;
5599       esac
5600
5601       if test -n "$objs"; then
5602         if test "$deplibs_check_method" != pass_all; then
5603           func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
5604         else
5605           $ECHO
5606           $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
5607           $ECHO "*** objects $objs is not portable!"
5608           libobjs="$libobjs $objs"
5609         fi
5610       fi
5611
5612       test "$dlself" != no && \
5613         func_warning "\`-dlopen self' is ignored for libtool libraries"
5614
5615       set dummy $rpath
5616       shift
5617       test "$#" -gt 1 && \
5618         func_warning "ignoring multiple \`-rpath's for a libtool library"
5619
5620       install_libdir="$1"
5621
5622       oldlibs=
5623       if test -z "$rpath"; then
5624         if test "$build_libtool_libs" = yes; then
5625           # Building a libtool convenience library.
5626           # Some compilers have problems with a `.al' extension so
5627           # convenience libraries should have the same extension an
5628           # archive normally would.
5629           oldlibs="$output_objdir/$libname.$libext $oldlibs"
5630           build_libtool_libs=convenience
5631           build_old_libs=yes
5632         fi
5633
5634         test -n "$vinfo" && \
5635           func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
5636
5637         test -n "$release" && \
5638           func_warning "\`-release' is ignored for convenience libraries"
5639       else
5640
5641         # Parse the version information argument.
5642         save_ifs="$IFS"; IFS=':'
5643         set dummy $vinfo 0 0 0
5644         shift
5645         IFS="$save_ifs"
5646
5647         test -n "$7" && \
5648           func_fatal_help "too many parameters to \`-version-info'"
5649
5650         # convert absolute version numbers to libtool ages
5651         # this retains compatibility with .la files and attempts
5652         # to make the code below a bit more comprehensible
5653
5654         case $vinfo_number in
5655         yes)
5656           number_major="$1"
5657           number_minor="$2"
5658           number_revision="$3"
5659           #
5660           # There are really only two kinds -- those that
5661           # use the current revision as the major version
5662           # and those that subtract age and use age as
5663           # a minor version.  But, then there is irix
5664           # which has an extra 1 added just for fun
5665           #
5666           case $version_type in
5667           darwin|linux|osf|windows|none)
5668             func_arith $number_major + $number_minor
5669             current=$func_arith_result
5670             age="$number_minor"
5671             revision="$number_revision"
5672             ;;
5673           freebsd-aout|freebsd-elf|sunos)
5674             current="$number_major"
5675             revision="$number_minor"
5676             age="0"
5677             ;;
5678           irix|nonstopux)
5679             func_arith $number_major + $number_minor
5680             current=$func_arith_result
5681             age="$number_minor"
5682             revision="$number_minor"
5683             lt_irix_increment=no
5684             ;;
5685           *)
5686             func_fatal_configuration "$modename: unknown library version type \`$version_type'"
5687             ;;
5688           esac
5689           ;;
5690         no)
5691           current="$1"
5692           revision="$2"
5693           age="$3"
5694           ;;
5695         esac
5696
5697         # Check that each of the things are valid numbers.
5698         case $current in
5699         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]) ;;
5700         *)
5701           func_error "CURRENT \`$current' must be a nonnegative integer"
5702           func_fatal_error "\`$vinfo' is not valid version information"
5703           ;;
5704         esac
5705
5706         case $revision in
5707         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]) ;;
5708         *)
5709           func_error "REVISION \`$revision' must be a nonnegative integer"
5710           func_fatal_error "\`$vinfo' is not valid version information"
5711           ;;
5712         esac
5713
5714         case $age in
5715         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]) ;;
5716         *)
5717           func_error "AGE \`$age' must be a nonnegative integer"
5718           func_fatal_error "\`$vinfo' is not valid version information"
5719           ;;
5720         esac
5721
5722         if test "$age" -gt "$current"; then
5723           func_error "AGE \`$age' is greater than the current interface number \`$current'"
5724           func_fatal_error "\`$vinfo' is not valid version information"
5725         fi
5726
5727         # Calculate the version variables.
5728         major=
5729         versuffix=
5730         verstring=
5731         case $version_type in
5732         none) ;;
5733
5734         darwin)
5735           # Like Linux, but with the current version available in
5736           # verstring for coding it into the library header
5737           func_arith $current - $age
5738           major=.$func_arith_result
5739           versuffix="$major.$age.$revision"
5740           # Darwin ld doesn't like 0 for these options...
5741           func_arith $current + 1
5742           minor_current=$func_arith_result
5743           xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
5744           verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
5745           ;;
5746
5747         freebsd-aout)
5748           major=".$current"
5749           versuffix=".$current.$revision";
5750           ;;
5751
5752         freebsd-elf)
5753           major=".$current"
5754           versuffix=".$current"
5755           ;;
5756
5757         irix | nonstopux)
5758           if test "X$lt_irix_increment" = "Xno"; then
5759             func_arith $current - $age
5760           else
5761             func_arith $current - $age + 1
5762           fi
5763           major=$func_arith_result
5764
5765           case $version_type in
5766             nonstopux) verstring_prefix=nonstopux ;;
5767             *)         verstring_prefix=sgi ;;
5768           esac
5769           verstring="$verstring_prefix$major.$revision"
5770
5771           # Add in all the interfaces that we are compatible with.
5772           loop=$revision
5773           while test "$loop" -ne 0; do
5774             func_arith $revision - $loop
5775             iface=$func_arith_result
5776             func_arith $loop - 1
5777             loop=$func_arith_result
5778             verstring="$verstring_prefix$major.$iface:$verstring"
5779           done
5780
5781           # Before this point, $major must not contain `.'.
5782           major=.$major
5783           versuffix="$major.$revision"
5784           ;;
5785
5786         linux)
5787           func_arith $current - $age
5788           major=.$func_arith_result
5789           versuffix="$major.$age.$revision"
5790           ;;
5791
5792         osf)
5793           func_arith $current - $age
5794           major=.$func_arith_result
5795           versuffix=".$current.$age.$revision"
5796           verstring="$current.$age.$revision"
5797
5798           # Add in all the interfaces that we are compatible with.
5799           loop=$age
5800           while test "$loop" -ne 0; do
5801             func_arith $current - $loop
5802             iface=$func_arith_result
5803             func_arith $loop - 1
5804             loop=$func_arith_result
5805             verstring="$verstring:${iface}.0"
5806           done
5807
5808           # Make executables depend on our current version.
5809           verstring="$verstring:${current}.0"
5810           ;;
5811
5812         qnx)
5813           major=".$current"
5814           versuffix=".$current"
5815           ;;
5816
5817         sunos)
5818           major=".$current"
5819           versuffix=".$current.$revision"
5820           ;;
5821
5822         windows)
5823           # Use '-' rather than '.', since we only want one
5824           # extension on DOS 8.3 filesystems.
5825           func_arith $current - $age
5826           major=$func_arith_result
5827           versuffix="-$major"
5828           ;;
5829
5830         *)
5831           func_fatal_configuration "unknown library version type \`$version_type'"
5832           ;;
5833         esac
5834
5835         # Clear the version info if we defaulted, and they specified a release.
5836         if test -z "$vinfo" && test -n "$release"; then
5837           major=
5838           case $version_type in
5839           darwin)
5840             # we can't check for "0.0" in archive_cmds due to quoting
5841             # problems, so we reset it completely
5842             verstring=
5843             ;;
5844           *)
5845             verstring="0.0"
5846             ;;
5847           esac
5848           if test "$need_version" = no; then
5849             versuffix=
5850           else
5851             versuffix=".0.0"
5852           fi
5853         fi
5854
5855         # Remove version info from name if versioning should be avoided
5856         if test "$avoid_version" = yes && test "$need_version" = no; then
5857           major=
5858           versuffix=
5859           verstring=""
5860         fi
5861
5862         # Check to see if the archive will have undefined symbols.
5863         if test "$allow_undefined" = yes; then
5864           if test "$allow_undefined_flag" = unsupported; then
5865             func_warning "undefined symbols not allowed in $host shared libraries"
5866             build_libtool_libs=no
5867             build_old_libs=yes
5868           fi
5869         else
5870           # Don't allow undefined symbols.
5871           allow_undefined_flag="$no_undefined_flag"
5872         fi
5873
5874       fi
5875
5876       func_generate_dlsyms "$libname" "$libname" "yes"
5877       libobjs="$libobjs $symfileobj"
5878       test "X$libobjs" = "X " && libobjs=
5879
5880       if test "$mode" != relink; then
5881         # Remove our outputs, but don't remove object files since they
5882         # may have been created when compiling PIC objects.
5883         removelist=
5884         tempremovelist=`$ECHO "$output_objdir/*"`
5885         for p in $tempremovelist; do
5886           case $p in
5887             *.$objext)
5888                ;;
5889             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
5890                if test "X$precious_files_regex" != "X"; then
5891                  if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
5892                  then
5893                    continue
5894                  fi
5895                fi
5896                removelist="$removelist $p"
5897                ;;
5898             *) ;;
5899           esac
5900         done
5901         test -n "$removelist" && \
5902           func_show_eval "${RM}r \$removelist"
5903       fi
5904
5905       # Now set the variables for building old libraries.
5906       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
5907         oldlibs="$oldlibs $output_objdir/$libname.$libext"
5908
5909         # Transform .lo files to .o files.
5910         oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
5911       fi
5912
5913       # Eliminate all temporary directories.
5914       #for path in $notinst_path; do
5915       # lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
5916       # deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
5917       # dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
5918       #done
5919
5920       if test -n "$xrpath"; then
5921         # If the user specified any rpath flags, then add them.
5922         temp_xrpath=
5923         for libdir in $xrpath; do
5924           temp_xrpath="$temp_xrpath -R$libdir"
5925           case "$finalize_rpath " in
5926           *" $libdir "*) ;;
5927           *) finalize_rpath="$finalize_rpath $libdir" ;;
5928           esac
5929         done
5930         if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
5931           dependency_libs="$temp_xrpath $dependency_libs"
5932         fi
5933       fi
5934
5935       # Make sure dlfiles contains only unique files that won't be dlpreopened
5936       old_dlfiles="$dlfiles"
5937       dlfiles=
5938       for lib in $old_dlfiles; do
5939         case " $dlprefiles $dlfiles " in
5940         *" $lib "*) ;;
5941         *) dlfiles="$dlfiles $lib" ;;
5942         esac
5943       done
5944
5945       # Make sure dlprefiles contains only unique files
5946       old_dlprefiles="$dlprefiles"
5947       dlprefiles=
5948       for lib in $old_dlprefiles; do
5949         case "$dlprefiles " in
5950         *" $lib "*) ;;
5951         *) dlprefiles="$dlprefiles $lib" ;;
5952         esac
5953       done
5954
5955       if test "$build_libtool_libs" = yes; then
5956         if test -n "$rpath"; then
5957           case $host in
5958           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
5959             # these systems don't actually have a c library (as such)!
5960             ;;
5961           *-*-rhapsody* | *-*-darwin1.[012])
5962             # Rhapsody C library is in the System framework
5963             deplibs="$deplibs System.ltframework"
5964             ;;
5965           *-*-netbsd*)
5966             # Don't link with libc until the a.out ld.so is fixed.
5967             ;;
5968           *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5969             # Do not include libc due to us having libc/libc_r.
5970             ;;
5971           *-*-sco3.2v5* | *-*-sco5v6*)
5972             # Causes problems with __ctype
5973             ;;
5974           *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5975             # Compiler inserts libc in the correct place for threads to work
5976             ;;
5977           *)
5978             # Add libc to deplibs on all other systems if necessary.
5979             if test "$build_libtool_need_lc" = "yes"; then
5980               deplibs="$deplibs -lc"
5981             fi
5982             ;;
5983           esac
5984         fi
5985
5986         # Transform deplibs into only deplibs that can be linked in shared.
5987         name_save=$name
5988         libname_save=$libname
5989         release_save=$release
5990         versuffix_save=$versuffix
5991         major_save=$major
5992         # I'm not sure if I'm treating the release correctly.  I think
5993         # release should show up in the -l (ie -lgmp5) so we don't want to
5994         # add it in twice.  Is that correct?
5995         release=""
5996         versuffix=""
5997         major=""
5998         newdeplibs=
5999         droppeddeps=no
6000         case $deplibs_check_method in
6001         pass_all)
6002           # Don't check for shared/static.  Everything works.
6003           # This might be a little naive.  We might want to check
6004           # whether the library exists or not.  But this is on
6005           # osf3 & osf4 and I'm not really sure... Just
6006           # implementing what was already the behavior.
6007           newdeplibs=$deplibs
6008           ;;
6009         test_compile)
6010           # This code stresses the "libraries are programs" paradigm to its
6011           # limits. Maybe even breaks it.  We compile a program, linking it
6012           # against the deplibs as a proxy for the library.  Then we can check
6013           # whether they linked in statically or dynamically with ldd.
6014           $opt_dry_run || $RM conftest.c
6015           cat > conftest.c <<EOF
6016           int main() { return 0; }
6017 EOF
6018           $opt_dry_run || $RM conftest
6019           if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
6020             ldd_output=`ldd conftest`
6021             for i in $deplibs; do
6022               case $i in
6023               -l*)
6024                 func_stripname -l '' "$i"
6025                 name=$func_stripname_result
6026                 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6027                   case " $predeps $postdeps " in
6028                   *" $i "*)
6029                     newdeplibs="$newdeplibs $i"
6030                     i=""
6031                     ;;
6032                   esac
6033                 fi
6034                 if test -n "$i" ; then
6035                   libname=`eval "\\$ECHO \"$libname_spec\""`
6036                   deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6037                   set dummy $deplib_matches; shift
6038                   deplib_match=$1
6039                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6040                     newdeplibs="$newdeplibs $i"
6041                   else
6042                     droppeddeps=yes
6043                     $ECHO
6044                     $ECHO "*** Warning: dynamic linker does not accept needed library $i."
6045                     $ECHO "*** I have the capability to make that library automatically link in when"
6046                     $ECHO "*** you link to this library.  But I can only do this if you have a"
6047                     $ECHO "*** shared version of the library, which I believe you do not have"
6048                     $ECHO "*** because a test_compile did reveal that the linker did not use it for"
6049                     $ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
6050                   fi
6051                 fi
6052                 ;;
6053               *)
6054                 newdeplibs="$newdeplibs $i"
6055                 ;;
6056               esac
6057             done
6058           else
6059             # Error occurred in the first compile.  Let's try to salvage
6060             # the situation: Compile a separate program for each library.
6061             for i in $deplibs; do
6062               case $i in
6063               -l*)
6064                 func_stripname -l '' "$i"
6065                 name=$func_stripname_result
6066                 $opt_dry_run || $RM conftest
6067                 if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
6068                   ldd_output=`ldd conftest`
6069                   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6070                     case " $predeps $postdeps " in
6071                     *" $i "*)
6072                       newdeplibs="$newdeplibs $i"
6073                       i=""
6074                       ;;
6075                     esac
6076                   fi
6077                   if test -n "$i" ; then
6078                     libname=`eval "\\$ECHO \"$libname_spec\""`
6079                     deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6080                     set dummy $deplib_matches; shift
6081                     deplib_match=$1
6082                     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6083                       newdeplibs="$newdeplibs $i"
6084                     else
6085                       droppeddeps=yes
6086                       $ECHO
6087                       $ECHO "*** Warning: dynamic linker does not accept needed library $i."
6088                       $ECHO "*** I have the capability to make that library automatically link in when"
6089                       $ECHO "*** you link to this library.  But I can only do this if you have a"
6090                       $ECHO "*** shared version of the library, which you do not appear to have"
6091                       $ECHO "*** because a test_compile did reveal that the linker did not use this one"
6092                       $ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
6093                     fi
6094                   fi
6095                 else
6096                   droppeddeps=yes
6097                   $ECHO
6098                   $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
6099                   $ECHO "*** make it link in!  You will probably need to install it or some"
6100                   $ECHO "*** library that it depends on before this library will be fully"
6101                   $ECHO "*** functional.  Installing it before continuing would be even better."
6102                 fi
6103                 ;;
6104               *)
6105                 newdeplibs="$newdeplibs $i"
6106                 ;;
6107               esac
6108             done
6109           fi
6110           ;;
6111         file_magic*)
6112           set dummy $deplibs_check_method; shift
6113           file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6114           for a_deplib in $deplibs; do
6115             case $a_deplib in
6116             -l*)
6117               func_stripname -l '' "$a_deplib"
6118               name=$func_stripname_result
6119               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6120                 case " $predeps $postdeps " in
6121                 *" $a_deplib "*)
6122                   newdeplibs="$newdeplibs $a_deplib"
6123                   a_deplib=""
6124                   ;;
6125                 esac
6126               fi
6127               if test -n "$a_deplib" ; then
6128                 libname=`eval "\\$ECHO \"$libname_spec\""`
6129                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6130                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6131                   for potent_lib in $potential_libs; do
6132                       # Follow soft links.
6133                       if ls -lLd "$potent_lib" 2>/dev/null |
6134                          $GREP " -> " >/dev/null; then
6135                         continue
6136                       fi
6137                       # The statement above tries to avoid entering an
6138                       # endless loop below, in case of cyclic links.
6139                       # We might still enter an endless loop, since a link
6140                       # loop can be closed while we follow links,
6141                       # but so what?
6142                       potlib="$potent_lib"
6143                       while test -h "$potlib" 2>/dev/null; do
6144                         potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
6145                         case $potliblink in
6146                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
6147                         *) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
6148                         esac
6149                       done
6150                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
6151                          $SED -e 10q |
6152                          $EGREP "$file_magic_regex" > /dev/null; then
6153                         newdeplibs="$newdeplibs $a_deplib"
6154                         a_deplib=""
6155                         break 2
6156                       fi
6157                   done
6158                 done
6159               fi
6160               if test -n "$a_deplib" ; then
6161                 droppeddeps=yes
6162                 $ECHO
6163                 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6164                 $ECHO "*** I have the capability to make that library automatically link in when"
6165                 $ECHO "*** you link to this library.  But I can only do this if you have a"
6166                 $ECHO "*** shared version of the library, which you do not appear to have"
6167                 $ECHO "*** because I did check the linker path looking for a file starting"
6168                 if test -z "$potlib" ; then
6169                   $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
6170                 else
6171                   $ECHO "*** with $libname and none of the candidates passed a file format test"
6172                   $ECHO "*** using a file magic. Last file checked: $potlib"
6173                 fi
6174               fi
6175               ;;
6176             *)
6177               # Add a -L argument.
6178               newdeplibs="$newdeplibs $a_deplib"
6179               ;;
6180             esac
6181           done # Gone through all deplibs.
6182           ;;
6183         match_pattern*)
6184           set dummy $deplibs_check_method; shift
6185           match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6186           for a_deplib in $deplibs; do
6187             case $a_deplib in
6188             -l*)
6189               func_stripname -l '' "$a_deplib"
6190               name=$func_stripname_result
6191               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6192                 case " $predeps $postdeps " in
6193                 *" $a_deplib "*)
6194                   newdeplibs="$newdeplibs $a_deplib"
6195                   a_deplib=""
6196                   ;;
6197                 esac
6198               fi
6199               if test -n "$a_deplib" ; then
6200                 libname=`eval "\\$ECHO \"$libname_spec\""`
6201                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6202                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6203                   for potent_lib in $potential_libs; do
6204                     potlib="$potent_lib" # see symlink-check above in file_magic test
6205                     if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
6206                        $EGREP "$match_pattern_regex" > /dev/null; then
6207                       newdeplibs="$newdeplibs $a_deplib"
6208                       a_deplib=""
6209                       break 2
6210                     fi
6211                   done
6212                 done
6213               fi
6214               if test -n "$a_deplib" ; then
6215                 droppeddeps=yes
6216                 $ECHO
6217                 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6218                 $ECHO "*** I have the capability to make that library automatically link in when"
6219                 $ECHO "*** you link to this library.  But I can only do this if you have a"
6220                 $ECHO "*** shared version of the library, which you do not appear to have"
6221                 $ECHO "*** because I did check the linker path looking for a file starting"
6222                 if test -z "$potlib" ; then
6223                   $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
6224                 else
6225                   $ECHO "*** with $libname and none of the candidates passed a file format test"
6226                   $ECHO "*** using a regex pattern. Last file checked: $potlib"
6227                 fi
6228               fi
6229               ;;
6230             *)
6231               # Add a -L argument.
6232               newdeplibs="$newdeplibs $a_deplib"
6233               ;;
6234             esac
6235           done # Gone through all deplibs.
6236           ;;
6237         none | unknown | *)
6238           newdeplibs=""
6239           tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
6240               -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
6241           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6242             for i in $predeps $postdeps ; do
6243               # can't use Xsed below, because $i might contain '/'
6244               tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
6245             done
6246           fi
6247           if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[      ]//g' |
6248              $GREP . >/dev/null; then
6249             $ECHO
6250             if test "X$deplibs_check_method" = "Xnone"; then
6251               $ECHO "*** Warning: inter-library dependencies are not supported in this platform."
6252             else
6253               $ECHO "*** Warning: inter-library dependencies are not known to be supported."
6254             fi
6255             $ECHO "*** All declared inter-library dependencies are being dropped."
6256             droppeddeps=yes
6257           fi
6258           ;;
6259         esac
6260         versuffix=$versuffix_save
6261         major=$major_save
6262         release=$release_save
6263         libname=$libname_save
6264         name=$name_save
6265
6266         case $host in
6267         *-*-rhapsody* | *-*-darwin1.[012])
6268           # On Rhapsody replace the C library with the System framework
6269           newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
6270           ;;
6271         esac
6272
6273         if test "$droppeddeps" = yes; then
6274           if test "$module" = yes; then
6275             $ECHO
6276             $ECHO "*** Warning: libtool could not satisfy all declared inter-library"
6277             $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
6278             $ECHO "*** a static module, that should work as long as the dlopening"
6279             $ECHO "*** application is linked with the -dlopen flag."
6280             if test -z "$global_symbol_pipe"; then
6281               $ECHO
6282               $ECHO "*** However, this would only work if libtool was able to extract symbol"
6283               $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
6284               $ECHO "*** not find such a program.  So, this module is probably useless."
6285               $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
6286             fi
6287             if test "$build_old_libs" = no; then
6288               oldlibs="$output_objdir/$libname.$libext"
6289               build_libtool_libs=module
6290               build_old_libs=yes
6291             else
6292               build_libtool_libs=no
6293             fi
6294           else
6295             $ECHO "*** The inter-library dependencies that have been dropped here will be"
6296             $ECHO "*** automatically added whenever a program is linked with this library"
6297             $ECHO "*** or is declared to -dlopen it."
6298
6299             if test "$allow_undefined" = no; then
6300               $ECHO
6301               $ECHO "*** Since this library must not contain undefined symbols,"
6302               $ECHO "*** because either the platform does not support them or"
6303               $ECHO "*** it was explicitly requested with -no-undefined,"
6304               $ECHO "*** libtool will only create a static version of it."
6305               if test "$build_old_libs" = no; then
6306                 oldlibs="$output_objdir/$libname.$libext"
6307                 build_libtool_libs=module
6308                 build_old_libs=yes
6309               else
6310                 build_libtool_libs=no
6311               fi
6312             fi
6313           fi
6314         fi
6315         # Done checking deplibs!
6316         deplibs=$newdeplibs
6317       fi
6318       # Time to change all our "foo.ltframework" stuff back to "-framework foo"
6319       case $host in
6320         *-*-darwin*)
6321           newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6322           new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6323           deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6324           ;;
6325       esac
6326
6327       # move library search paths that coincide with paths to not yet
6328       # installed libraries to the beginning of the library search list
6329       new_libs=
6330       for path in $notinst_path; do
6331         case " $new_libs " in
6332         *" -L$path/$objdir "*) ;;
6333         *)
6334           case " $deplibs " in
6335           *" -L$path/$objdir "*)
6336             new_libs="$new_libs -L$path/$objdir" ;;
6337           esac
6338           ;;
6339         esac
6340       done
6341       for deplib in $deplibs; do
6342         case $deplib in
6343         -L*)
6344           case " $new_libs " in
6345           *" $deplib "*) ;;
6346           *) new_libs="$new_libs $deplib" ;;
6347           esac
6348           ;;
6349         *) new_libs="$new_libs $deplib" ;;
6350         esac
6351       done
6352       deplibs="$new_libs"
6353
6354       # All the library-specific variables (install_libdir is set above).
6355       library_names=
6356       old_library=
6357       dlname=
6358
6359       # Test again, we may have decided not to build it any more
6360       if test "$build_libtool_libs" = yes; then
6361         if test "$hardcode_into_libs" = yes; then
6362           # Hardcode the library paths
6363           hardcode_libdirs=
6364           dep_rpath=
6365           rpath="$finalize_rpath"
6366           test "$mode" != relink && rpath="$compile_rpath$rpath"
6367           for libdir in $rpath; do
6368             if test -n "$hardcode_libdir_flag_spec"; then
6369               if test -n "$hardcode_libdir_separator"; then
6370                 if test -z "$hardcode_libdirs"; then
6371                   hardcode_libdirs="$libdir"
6372                 else
6373                   # Just accumulate the unique libdirs.
6374                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
6375                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
6376                     ;;
6377                   *)
6378                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
6379                     ;;
6380                   esac
6381                 fi
6382               else
6383                 eval flag=\"$hardcode_libdir_flag_spec\"
6384                 dep_rpath="$dep_rpath $flag"
6385               fi
6386             elif test -n "$runpath_var"; then
6387               case "$perm_rpath " in
6388               *" $libdir "*) ;;
6389               *) perm_rpath="$perm_rpath $libdir" ;;
6390               esac
6391             fi
6392           done
6393           # Substitute the hardcoded libdirs into the rpath.
6394           if test -n "$hardcode_libdir_separator" &&
6395              test -n "$hardcode_libdirs"; then
6396             libdir="$hardcode_libdirs"
6397             if test -n "$hardcode_libdir_flag_spec_ld"; then
6398               eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
6399             else
6400               eval dep_rpath=\"$hardcode_libdir_flag_spec\"
6401             fi
6402           fi
6403           if test -n "$runpath_var" && test -n "$perm_rpath"; then
6404             # We should set the runpath_var.
6405             rpath=
6406             for dir in $perm_rpath; do
6407               rpath="$rpath$dir:"
6408             done
6409             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
6410           fi
6411           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
6412         fi
6413
6414         shlibpath="$finalize_shlibpath"
6415         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
6416         if test -n "$shlibpath"; then
6417           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
6418         fi
6419
6420         # Get the real and link names of the library.
6421         eval shared_ext=\"$shrext_cmds\"
6422         eval library_names=\"$library_names_spec\"
6423         set dummy $library_names
6424         shift
6425         realname="$1"
6426         shift
6427
6428         if test -n "$soname_spec"; then
6429           eval soname=\"$soname_spec\"
6430         else
6431           soname="$realname"
6432         fi
6433         if test -z "$dlname"; then
6434           dlname=$soname
6435         fi
6436
6437         lib="$output_objdir/$realname"
6438         linknames=
6439         for link
6440         do
6441           linknames="$linknames $link"
6442         done
6443
6444         # Use standard objects if they are pic
6445         test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
6446         test "X$libobjs" = "X " && libobjs=
6447
6448         delfiles=
6449         if test -n "$export_symbols" && test -n "$include_expsyms"; then
6450           $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
6451           export_symbols="$output_objdir/$libname.uexp"
6452           delfiles="$delfiles $export_symbols"
6453         fi
6454
6455         orig_export_symbols=
6456         case $host_os in
6457         cygwin* | mingw*)
6458           if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
6459             # exporting using user supplied symfile
6460             if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
6461               # and it's NOT already a .def file. Must figure out
6462               # which of the given symbols are data symbols and tag
6463               # them as such. So, trigger use of export_symbols_cmds.
6464               # export_symbols gets reassigned inside the "prepare
6465               # the list of exported symbols" if statement, so the
6466               # include_expsyms logic still works.
6467               orig_export_symbols="$export_symbols"
6468               export_symbols=
6469               always_export_symbols=yes
6470             fi
6471           fi
6472           ;;
6473         esac
6474
6475         # Prepare the list of exported symbols
6476         if test -z "$export_symbols"; then
6477           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
6478             func_verbose "generating symbol list for \`$libname.la'"
6479             export_symbols="$output_objdir/$libname.exp"
6480             $opt_dry_run || $RM $export_symbols
6481             cmds=$export_symbols_cmds
6482             save_ifs="$IFS"; IFS='~'
6483             for cmd in $cmds; do
6484               IFS="$save_ifs"
6485               eval cmd=\"$cmd\"
6486               func_len " $cmd"
6487               len=$func_len_result
6488               if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
6489                 func_show_eval "$cmd" 'exit $?'
6490                 skipped_export=false
6491               else
6492                 # The command line is too long to execute in one step.
6493                 func_verbose "using reloadable object file for export list..."
6494                 skipped_export=:
6495                 # Break out early, otherwise skipped_export may be
6496                 # set to false by a later but shorter cmd.
6497                 break
6498               fi
6499             done
6500             IFS="$save_ifs"
6501             if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
6502               func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
6503               func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
6504             fi
6505           fi
6506         fi
6507
6508         if test -n "$export_symbols" && test -n "$include_expsyms"; then
6509           tmp_export_symbols="$export_symbols"
6510           test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
6511           $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
6512         fi
6513
6514         if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
6515           # The given exports_symbols file has to be filtered, so filter it.
6516           func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
6517           # FIXME: $output_objdir/$libname.filter potentially contains lots of
6518           # 's' commands which not all seds can handle. GNU sed should be fine
6519           # though. Also, the filter scales superlinearly with the number of
6520           # global variables. join(1) would be nice here, but unfortunately
6521           # isn't a blessed tool.
6522           $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
6523           delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
6524           export_symbols=$output_objdir/$libname.def
6525           $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
6526         fi
6527
6528         tmp_deplibs=
6529         for test_deplib in $deplibs; do
6530           case " $convenience " in
6531           *" $test_deplib "*) ;;
6532           *)
6533             tmp_deplibs="$tmp_deplibs $test_deplib"
6534             ;;
6535           esac
6536         done
6537         deplibs="$tmp_deplibs"
6538
6539         if test -n "$convenience"; then
6540           if test -n "$whole_archive_flag_spec" &&
6541             test "$compiler_needs_object" = yes &&
6542             test -z "$libobjs"; then
6543             # extract the archives, so we have objects to list.
6544             # TODO: could optimize this to just extract one archive.
6545             whole_archive_flag_spec=
6546           fi
6547           if test -n "$whole_archive_flag_spec"; then
6548             save_libobjs=$libobjs
6549             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
6550             test "X$libobjs" = "X " && libobjs=
6551           else
6552             gentop="$output_objdir/${outputname}x"
6553             generated="$generated $gentop"
6554
6555             func_extract_archives $gentop $convenience
6556             libobjs="$libobjs $func_extract_archives_result"
6557             test "X$libobjs" = "X " && libobjs=
6558           fi
6559         fi
6560
6561         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
6562           eval flag=\"$thread_safe_flag_spec\"
6563           linker_flags="$linker_flags $flag"
6564         fi
6565
6566         # Make a backup of the uninstalled library when relinking
6567         if test "$mode" = relink; then
6568           $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
6569         fi
6570
6571         # Do each of the archive commands.
6572         if test "$module" = yes && test -n "$module_cmds" ; then
6573           if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
6574             eval test_cmds=\"$module_expsym_cmds\"
6575             cmds=$module_expsym_cmds
6576           else
6577             eval test_cmds=\"$module_cmds\"
6578             cmds=$module_cmds
6579           fi
6580         else
6581           if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
6582             eval test_cmds=\"$archive_expsym_cmds\"
6583             cmds=$archive_expsym_cmds
6584           else
6585             eval test_cmds=\"$archive_cmds\"
6586             cmds=$archive_cmds
6587           fi
6588         fi
6589
6590         if test "X$skipped_export" != "X:" &&
6591            func_len " $test_cmds" &&
6592            len=$func_len_result &&
6593            test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
6594           :
6595         else
6596           # The command line is too long to link in one step, link piecewise
6597           # or, if using GNU ld and skipped_export is not :, use a linker
6598           # script.
6599
6600           # Save the value of $output and $libobjs because we want to
6601           # use them later.  If we have whole_archive_flag_spec, we
6602           # want to use save_libobjs as it was before
6603           # whole_archive_flag_spec was expanded, because we can't
6604           # assume the linker understands whole_archive_flag_spec.
6605           # This may have to be revisited, in case too many
6606           # convenience libraries get linked in and end up exceeding
6607           # the spec.
6608           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
6609             save_libobjs=$libobjs
6610           fi
6611           save_output=$output
6612           output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
6613
6614           # Clear the reloadable object creation command queue and
6615           # initialize k to one.
6616           test_cmds=
6617           concat_cmds=
6618           objlist=
6619           last_robj=
6620           k=1
6621
6622           if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
6623             output=${output_objdir}/${output_la}.lnkscript
6624             func_verbose "creating GNU ld script: $output"
6625             $ECHO 'INPUT (' > $output
6626             for obj in $save_libobjs
6627             do
6628               $ECHO "$obj" >> $output
6629             done
6630             $ECHO ')' >> $output
6631             delfiles="$delfiles $output"
6632           elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
6633             output=${output_objdir}/${output_la}.lnk
6634             func_verbose "creating linker input file list: $output"
6635             : > $output
6636             set x $save_libobjs
6637             shift
6638             firstobj=
6639             if test "$compiler_needs_object" = yes; then
6640               firstobj="$1 "
6641               shift
6642             fi
6643             for obj
6644             do
6645               $ECHO "$obj" >> $output
6646             done
6647             delfiles="$delfiles $output"
6648             output=$firstobj\"$file_list_spec$output\"
6649           else
6650             if test -n "$save_libobjs"; then
6651               func_verbose "creating reloadable object files..."
6652               output=$output_objdir/$output_la-${k}.$objext
6653               eval test_cmds=\"$reload_cmds\"
6654               func_len " $test_cmds"
6655               len0=$func_len_result
6656               len=$len0
6657
6658               # Loop over the list of objects to be linked.
6659               for obj in $save_libobjs
6660               do
6661                 func_len " $obj"
6662                 func_arith $len + $func_len_result
6663                 len=$func_arith_result
6664                 if test "X$objlist" = X ||
6665                    test "$len" -lt "$max_cmd_len"; then
6666                   func_append objlist " $obj"
6667                 else
6668                   # The command $test_cmds is almost too long, add a
6669                   # command to the queue.
6670                   if test "$k" -eq 1 ; then
6671                     # The first file doesn't have a previous command to add.
6672                     eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
6673                   else
6674                     # All subsequent reloadable object files will link in
6675                     # the last one created.
6676                     eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"
6677                   fi
6678                   last_robj=$output_objdir/$output_la-${k}.$objext
6679                   func_arith $k + 1
6680                   k=$func_arith_result
6681                   output=$output_objdir/$output_la-${k}.$objext
6682                   objlist=$obj
6683                   func_len " $last_robj"
6684                   func_arith $len0 + $func_len_result
6685                   len=$func_arith_result
6686                 fi
6687               done
6688               # Handle the remaining objects by creating one last
6689               # reloadable object file.  All subsequent reloadable object
6690               # files will link in the last one created.
6691               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
6692               eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
6693               if test -n "$last_robj"; then
6694                 eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
6695               fi
6696               delfiles="$delfiles $output"
6697
6698             else
6699               output=
6700             fi
6701
6702             if ${skipped_export-false}; then
6703               func_verbose "generating symbol list for \`$libname.la'"
6704               export_symbols="$output_objdir/$libname.exp"
6705               $opt_dry_run || $RM $export_symbols
6706               libobjs=$output
6707               # Append the command to create the export file.
6708               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
6709               eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
6710               if test -n "$last_robj"; then
6711                 eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
6712               fi
6713             fi
6714
6715             test -n "$save_libobjs" &&
6716               func_verbose "creating a temporary reloadable object file: $output"
6717
6718             # Loop through the commands generated above and execute them.
6719             save_ifs="$IFS"; IFS='~'
6720             for cmd in $concat_cmds; do
6721               IFS="$save_ifs"
6722               $opt_silent || {
6723                   func_quote_for_expand "$cmd"
6724                   eval "func_echo $func_quote_for_expand_result"
6725               }
6726               $opt_dry_run || eval "$cmd" || {
6727                 lt_exit=$?
6728
6729                 # Restore the uninstalled library and exit
6730                 if test "$mode" = relink; then
6731                   ( cd "$output_objdir" && \
6732                     $RM "${realname}T" && \
6733                     $MV "${realname}U" "$realname" )
6734                 fi
6735
6736                 exit $lt_exit
6737               }
6738             done
6739             IFS="$save_ifs"
6740
6741             if test -n "$export_symbols_regex" && ${skipped_export-false}; then
6742               func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
6743               func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
6744             fi
6745           fi
6746
6747           if ${skipped_export-false}; then
6748             if test -n "$export_symbols" && test -n "$include_expsyms"; then
6749               tmp_export_symbols="$export_symbols"
6750               test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
6751               $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
6752             fi
6753
6754             if test -n "$orig_export_symbols"; then
6755               # The given exports_symbols file has to be filtered, so filter it.
6756               func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
6757               # FIXME: $output_objdir/$libname.filter potentially contains lots of
6758               # 's' commands which not all seds can handle. GNU sed should be fine
6759               # though. Also, the filter scales superlinearly with the number of
6760               # global variables. join(1) would be nice here, but unfortunately
6761               # isn't a blessed tool.
6762               $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
6763               delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
6764               export_symbols=$output_objdir/$libname.def
6765               $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
6766             fi
6767           fi
6768
6769           libobjs=$output
6770           # Restore the value of output.
6771           output=$save_output
6772
6773           if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
6774             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
6775             test "X$libobjs" = "X " && libobjs=
6776           fi
6777           # Expand the library linking commands again to reset the
6778           # value of $libobjs for piecewise linking.
6779
6780           # Do each of the archive commands.
6781           if test "$module" = yes && test -n "$module_cmds" ; then
6782             if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
6783               cmds=$module_expsym_cmds
6784             else
6785               cmds=$module_cmds
6786             fi
6787           else
6788             if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
6789               cmds=$archive_expsym_cmds
6790             else
6791               cmds=$archive_cmds
6792             fi
6793           fi
6794         fi
6795
6796         if test -n "$delfiles"; then
6797           # Append the command to remove temporary files to $cmds.
6798           eval cmds=\"\$cmds~\$RM $delfiles\"
6799         fi
6800
6801         # Add any objects from preloaded convenience libraries
6802         if test -n "$dlprefiles"; then
6803           gentop="$output_objdir/${outputname}x"
6804           generated="$generated $gentop"
6805
6806           func_extract_archives $gentop $dlprefiles
6807           libobjs="$libobjs $func_extract_archives_result"
6808           test "X$libobjs" = "X " && libobjs=
6809         fi
6810
6811         save_ifs="$IFS"; IFS='~'
6812         for cmd in $cmds; do
6813           IFS="$save_ifs"
6814           eval cmd=\"$cmd\"
6815           $opt_silent || {
6816             func_quote_for_expand "$cmd"
6817             eval "func_echo $func_quote_for_expand_result"
6818           }
6819           $opt_dry_run || eval "$cmd" || {
6820             lt_exit=$?
6821
6822             # Restore the uninstalled library and exit
6823             if test "$mode" = relink; then
6824               ( cd "$output_objdir" && \
6825                 $RM "${realname}T" && \
6826                 $MV "${realname}U" "$realname" )
6827             fi
6828
6829             exit $lt_exit
6830           }
6831         done
6832         IFS="$save_ifs"
6833
6834         # Restore the uninstalled library and exit
6835         if test "$mode" = relink; then
6836           $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
6837
6838           if test -n "$convenience"; then
6839             if test -z "$whole_archive_flag_spec"; then
6840               func_show_eval '${RM}r "$gentop"'
6841             fi
6842           fi
6843
6844           exit $EXIT_SUCCESS
6845         fi
6846
6847         # Create links to the real library.
6848         for linkname in $linknames; do
6849           if test "$realname" != "$linkname"; then
6850             func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
6851           fi
6852         done
6853
6854         # If -module or -export-dynamic was specified, set the dlname.
6855         if test "$module" = yes || test "$export_dynamic" = yes; then
6856           # On all known operating systems, these are identical.
6857           dlname="$soname"
6858         fi
6859       fi
6860       ;;
6861
6862     obj)
6863       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
6864         func_warning "\`-dlopen' is ignored for objects"
6865       fi
6866
6867       case " $deplibs" in
6868       *\ -l* | *\ -L*)
6869         func_warning "\`-l' and \`-L' are ignored for objects" ;;
6870       esac
6871
6872       test -n "$rpath" && \
6873         func_warning "\`-rpath' is ignored for objects"
6874
6875       test -n "$xrpath" && \
6876         func_warning "\`-R' is ignored for objects"
6877
6878       test -n "$vinfo" && \
6879         func_warning "\`-version-info' is ignored for objects"
6880
6881       test -n "$release" && \
6882         func_warning "\`-release' is ignored for objects"
6883
6884       case $output in
6885       *.lo)
6886         test -n "$objs$old_deplibs" && \
6887           func_fatal_error "cannot build library object \`$output' from non-libtool objects"
6888
6889         libobj=$output
6890         func_lo2o "$libobj"
6891         obj=$func_lo2o_result
6892         ;;
6893       *)
6894         libobj=
6895         obj="$output"
6896         ;;
6897       esac
6898
6899       # Delete the old objects.
6900       $opt_dry_run || $RM $obj $libobj
6901
6902       # Objects from convenience libraries.  This assumes
6903       # single-version convenience libraries.  Whenever we create
6904       # different ones for PIC/non-PIC, this we'll have to duplicate
6905       # the extraction.
6906       reload_conv_objs=
6907       gentop=
6908       # reload_cmds runs $LD directly, so let us get rid of
6909       # -Wl from whole_archive_flag_spec and hope we can get by with
6910       # turning comma into space..
6911       wl=
6912
6913       if test -n "$convenience"; then
6914         if test -n "$whole_archive_flag_spec"; then
6915           eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
6916           reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
6917         else
6918           gentop="$output_objdir/${obj}x"
6919           generated="$generated $gentop"
6920
6921           func_extract_archives $gentop $convenience
6922           reload_conv_objs="$reload_objs $func_extract_archives_result"
6923         fi
6924       fi
6925
6926       # Create the old-style object.
6927       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
6928
6929       output="$obj"
6930       func_execute_cmds "$reload_cmds" 'exit $?'
6931
6932       # Exit if we aren't doing a library object file.
6933       if test -z "$libobj"; then
6934         if test -n "$gentop"; then
6935           func_show_eval '${RM}r "$gentop"'
6936         fi
6937
6938         exit $EXIT_SUCCESS
6939       fi
6940
6941       if test "$build_libtool_libs" != yes; then
6942         if test -n "$gentop"; then
6943           func_show_eval '${RM}r "$gentop"'
6944         fi
6945
6946         # Create an invalid libtool object if no PIC, so that we don't
6947         # accidentally link it into a program.
6948         # $show "echo timestamp > $libobj"
6949         # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
6950         exit $EXIT_SUCCESS
6951       fi
6952
6953       if test -n "$pic_flag" || test "$pic_mode" != default; then
6954         # Only do commands if we really have different PIC objects.
6955         reload_objs="$libobjs $reload_conv_objs"
6956         output="$libobj"
6957         func_execute_cmds "$reload_cmds" 'exit $?'
6958       fi
6959
6960       if test -n "$gentop"; then
6961         func_show_eval '${RM}r "$gentop"'
6962       fi
6963
6964       exit $EXIT_SUCCESS
6965       ;;
6966
6967     prog)
6968       case $host in
6969         *cygwin*) func_stripname '' '.exe' "$output"
6970                   output=$func_stripname_result.exe;;
6971       esac
6972       test -n "$vinfo" && \
6973         func_warning "\`-version-info' is ignored for programs"
6974
6975       test -n "$release" && \
6976         func_warning "\`-release' is ignored for programs"
6977
6978       test "$preload" = yes \
6979         && test "$dlopen_support" = unknown \
6980         && test "$dlopen_self" = unknown \
6981         && test "$dlopen_self_static" = unknown && \
6982           func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
6983
6984       case $host in
6985       *-*-rhapsody* | *-*-darwin1.[012])
6986         # On Rhapsody replace the C library is the System framework
6987         compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
6988         finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
6989         ;;
6990       esac
6991
6992       case $host in
6993       *-*-darwin*)
6994         # Don't allow lazy linking, it breaks C++ global constructors
6995         # But is supposedly fixed on 10.4 or later (yay!).
6996         if test "$tagname" = CXX ; then
6997           case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
6998             10.[0123])
6999               compile_command="$compile_command ${wl}-bind_at_load"
7000               finalize_command="$finalize_command ${wl}-bind_at_load"
7001             ;;
7002           esac
7003         fi
7004         # Time to change all our "foo.ltframework" stuff back to "-framework foo"
7005         compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7006         finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7007         ;;
7008       esac
7009
7010
7011       # move library search paths that coincide with paths to not yet
7012       # installed libraries to the beginning of the library search list
7013       new_libs=
7014       for path in $notinst_path; do
7015         case " $new_libs " in
7016         *" -L$path/$objdir "*) ;;
7017         *)
7018           case " $compile_deplibs " in
7019           *" -L$path/$objdir "*)
7020             new_libs="$new_libs -L$path/$objdir" ;;
7021           esac
7022           ;;
7023         esac
7024       done
7025       for deplib in $compile_deplibs; do
7026         case $deplib in
7027         -L*)
7028           case " $new_libs " in
7029           *" $deplib "*) ;;
7030           *) new_libs="$new_libs $deplib" ;;
7031           esac
7032           ;;
7033         *) new_libs="$new_libs $deplib" ;;
7034         esac
7035       done
7036       compile_deplibs="$new_libs"
7037
7038
7039       compile_command="$compile_command $compile_deplibs"
7040       finalize_command="$finalize_command $finalize_deplibs"
7041
7042       if test -n "$rpath$xrpath"; then
7043         # If the user specified any rpath flags, then add them.
7044         for libdir in $rpath $xrpath; do
7045           # This is the magic to use -rpath.
7046           case "$finalize_rpath " in
7047           *" $libdir "*) ;;
7048           *) finalize_rpath="$finalize_rpath $libdir" ;;
7049           esac
7050         done
7051       fi
7052
7053       # Now hardcode the library paths
7054       rpath=
7055       hardcode_libdirs=
7056       for libdir in $compile_rpath $finalize_rpath; do
7057         if test -n "$hardcode_libdir_flag_spec"; then
7058           if test -n "$hardcode_libdir_separator"; then
7059             if test -z "$hardcode_libdirs"; then
7060               hardcode_libdirs="$libdir"
7061             else
7062               # Just accumulate the unique libdirs.
7063               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7064               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7065                 ;;
7066               *)
7067                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7068                 ;;
7069               esac
7070             fi
7071           else
7072             eval flag=\"$hardcode_libdir_flag_spec\"
7073             rpath="$rpath $flag"
7074           fi
7075         elif test -n "$runpath_var"; then
7076           case "$perm_rpath " in
7077           *" $libdir "*) ;;
7078           *) perm_rpath="$perm_rpath $libdir" ;;
7079           esac
7080         fi
7081         case $host in
7082         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
7083           testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
7084           case :$dllsearchpath: in
7085           *":$libdir:"*) ;;
7086           *) dllsearchpath="$dllsearchpath:$libdir";;
7087           esac
7088           case :$dllsearchpath: in
7089           *":$testbindir:"*) ;;
7090           *) dllsearchpath="$dllsearchpath:$testbindir";;
7091           esac
7092           ;;
7093         esac
7094       done
7095       # Substitute the hardcoded libdirs into the rpath.
7096       if test -n "$hardcode_libdir_separator" &&
7097          test -n "$hardcode_libdirs"; then
7098         libdir="$hardcode_libdirs"
7099         eval rpath=\" $hardcode_libdir_flag_spec\"
7100       fi
7101       compile_rpath="$rpath"
7102
7103       rpath=
7104       hardcode_libdirs=
7105       for libdir in $finalize_rpath; do
7106         if test -n "$hardcode_libdir_flag_spec"; then
7107           if test -n "$hardcode_libdir_separator"; then
7108             if test -z "$hardcode_libdirs"; then
7109               hardcode_libdirs="$libdir"
7110             else
7111               # Just accumulate the unique libdirs.
7112               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7113               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7114                 ;;
7115               *)
7116                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7117                 ;;
7118               esac
7119             fi
7120           else
7121             eval flag=\"$hardcode_libdir_flag_spec\"
7122             rpath="$rpath $flag"
7123           fi
7124         elif test -n "$runpath_var"; then
7125           case "$finalize_perm_rpath " in
7126           *" $libdir "*) ;;
7127           *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
7128           esac
7129         fi
7130       done
7131       # Substitute the hardcoded libdirs into the rpath.
7132       if test -n "$hardcode_libdir_separator" &&
7133          test -n "$hardcode_libdirs"; then
7134         libdir="$hardcode_libdirs"
7135         eval rpath=\" $hardcode_libdir_flag_spec\"
7136       fi
7137       finalize_rpath="$rpath"
7138
7139       if test -n "$libobjs" && test "$build_old_libs" = yes; then
7140         # Transform all the library objects into standard objects.
7141         compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7142         finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7143       fi
7144
7145       func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
7146
7147       # template prelinking step
7148       if test -n "$prelink_cmds"; then
7149         func_execute_cmds "$prelink_cmds" 'exit $?'
7150       fi
7151
7152       wrappers_required=yes
7153       case $host in
7154       *cygwin* | *mingw* )
7155         if test "$build_libtool_libs" != yes; then
7156           wrappers_required=no
7157         fi
7158         ;;
7159       *)
7160         if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
7161           wrappers_required=no
7162         fi
7163         ;;
7164       esac
7165       if test "$wrappers_required" = no; then
7166         # Replace the output file specification.
7167         compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
7168         link_command="$compile_command$compile_rpath"
7169
7170         # We have no uninstalled library dependencies, so finalize right now.
7171         exit_status=0
7172         func_show_eval "$link_command" 'exit_status=$?'
7173
7174         # Delete the generated files.
7175         if test -f "$output_objdir/${outputname}S.${objext}"; then
7176           func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
7177         fi
7178
7179         exit $exit_status
7180       fi
7181
7182       if test -n "$compile_shlibpath$finalize_shlibpath"; then
7183         compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
7184       fi
7185       if test -n "$finalize_shlibpath"; then
7186         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
7187       fi
7188
7189       compile_var=
7190       finalize_var=
7191       if test -n "$runpath_var"; then
7192         if test -n "$perm_rpath"; then
7193           # We should set the runpath_var.
7194           rpath=
7195           for dir in $perm_rpath; do
7196             rpath="$rpath$dir:"
7197           done
7198           compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
7199         fi
7200         if test -n "$finalize_perm_rpath"; then
7201           # We should set the runpath_var.
7202           rpath=
7203           for dir in $finalize_perm_rpath; do
7204             rpath="$rpath$dir:"
7205           done
7206           finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
7207         fi
7208       fi
7209
7210       if test "$no_install" = yes; then
7211         # We don't need to create a wrapper script.
7212         link_command="$compile_var$compile_command$compile_rpath"
7213         # Replace the output file specification.
7214         link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
7215         # Delete the old output file.
7216         $opt_dry_run || $RM $output
7217         # Link the executable and exit
7218         func_show_eval "$link_command" 'exit $?'
7219         exit $EXIT_SUCCESS
7220       fi
7221
7222       if test "$hardcode_action" = relink; then
7223         # Fast installation is not supported
7224         link_command="$compile_var$compile_command$compile_rpath"
7225         relink_command="$finalize_var$finalize_command$finalize_rpath"
7226
7227         func_warning "this platform does not like uninstalled shared libraries"
7228         func_warning "\`$output' will be relinked during installation"
7229       else
7230         if test "$fast_install" != no; then
7231           link_command="$finalize_var$compile_command$finalize_rpath"
7232           if test "$fast_install" = yes; then
7233             relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
7234           else
7235             # fast_install is set to needless
7236             relink_command=
7237           fi
7238         else
7239           link_command="$compile_var$compile_command$compile_rpath"
7240           relink_command="$finalize_var$finalize_command$finalize_rpath"
7241         fi
7242       fi
7243
7244       # Replace the output file specification.
7245       link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7246
7247       # Delete the old output files.
7248       $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
7249
7250       func_show_eval "$link_command" 'exit $?'
7251
7252       # Now create the wrapper script.
7253       func_verbose "creating $output"
7254
7255       # Quote the relink command for shipping.
7256       if test -n "$relink_command"; then
7257         # Preserve any variables that may affect compiler behavior
7258         for var in $variables_saved_for_relink; do
7259           if eval test -z \"\${$var+set}\"; then
7260             relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
7261           elif eval var_value=\$$var; test -z "$var_value"; then
7262             relink_command="$var=; export $var; $relink_command"
7263           else
7264             func_quote_for_eval "$var_value"
7265             relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
7266           fi
7267         done
7268         relink_command="(cd `pwd`; $relink_command)"
7269         relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
7270       fi
7271
7272       # Quote $ECHO for shipping.
7273       if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
7274         case $progpath in
7275         [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
7276         *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
7277         esac
7278         qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
7279       else
7280         qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
7281       fi
7282
7283       # Only actually do things if not in dry run mode.
7284       $opt_dry_run || {
7285         # win32 will think the script is a binary if it has
7286         # a .exe suffix, so we strip it off here.
7287         case $output in
7288           *.exe) func_stripname '' '.exe' "$output"
7289                  output=$func_stripname_result ;;
7290         esac
7291         # test for cygwin because mv fails w/o .exe extensions
7292         case $host in
7293           *cygwin*)
7294             exeext=.exe
7295             func_stripname '' '.exe' "$outputname"
7296             outputname=$func_stripname_result ;;
7297           *) exeext= ;;
7298         esac
7299         case $host in
7300           *cygwin* | *mingw* )
7301             func_dirname_and_basename "$output" "" "."
7302             output_name=$func_basename_result
7303             output_path=$func_dirname_result
7304             cwrappersource="$output_path/$objdir/lt-$output_name.c"
7305             cwrapper="$output_path/$output_name.exe"
7306             $RM $cwrappersource $cwrapper
7307             trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
7308
7309             func_emit_cwrapperexe_src > $cwrappersource
7310
7311             # we should really use a build-platform specific compiler
7312             # here, but OTOH, the wrappers (shell script and this C one)
7313             # are only useful if you want to execute the "real" binary.
7314             # Since the "real" binary is built for $host, then this
7315             # wrapper might as well be built for $host, too.
7316             $opt_dry_run || {
7317               $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
7318               $STRIP $cwrapper
7319             }
7320
7321             # Now, create the wrapper script for func_source use:
7322             func_ltwrapper_scriptname $cwrapper
7323             $RM $func_ltwrapper_scriptname_result
7324             trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
7325             $opt_dry_run || {
7326               # note: this script will not be executed, so do not chmod.
7327               if test "x$build" = "x$host" ; then
7328                 $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
7329               else
7330                 func_emit_wrapper no > $func_ltwrapper_scriptname_result
7331               fi
7332             }
7333           ;;
7334           * )
7335             $RM $output
7336             trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
7337
7338             func_emit_wrapper no > $output
7339             chmod +x $output
7340           ;;
7341         esac
7342       }
7343       exit $EXIT_SUCCESS
7344       ;;
7345     esac
7346
7347     # See if we need to build an old-fashioned archive.
7348     for oldlib in $oldlibs; do
7349
7350       if test "$build_libtool_libs" = convenience; then
7351         oldobjs="$libobjs_save $symfileobj"
7352         addlibs="$convenience"
7353         build_libtool_libs=no
7354       else
7355         if test "$build_libtool_libs" = module; then
7356           oldobjs="$libobjs_save"
7357           build_libtool_libs=no
7358         else
7359           oldobjs="$old_deplibs $non_pic_objects"
7360           if test "$preload" = yes && test -f "$symfileobj"; then
7361             oldobjs="$oldobjs $symfileobj"
7362           fi
7363         fi
7364         addlibs="$old_convenience"
7365       fi
7366
7367       if test -n "$addlibs"; then
7368         gentop="$output_objdir/${outputname}x"
7369         generated="$generated $gentop"
7370
7371         func_extract_archives $gentop $addlibs
7372         oldobjs="$oldobjs $func_extract_archives_result"
7373       fi
7374
7375       # Do each command in the archive commands.
7376       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
7377         cmds=$old_archive_from_new_cmds
7378       else
7379
7380         # Add any objects from preloaded convenience libraries
7381         if test -n "$dlprefiles"; then
7382           gentop="$output_objdir/${outputname}x"
7383           generated="$generated $gentop"
7384
7385           func_extract_archives $gentop $dlprefiles
7386           oldobjs="$oldobjs $func_extract_archives_result"
7387         fi
7388
7389         # POSIX demands no paths to be encoded in archives.  We have
7390         # to avoid creating archives with duplicate basenames if we
7391         # might have to extract them afterwards, e.g., when creating a
7392         # static archive out of a convenience library, or when linking
7393         # the entirety of a libtool archive into another (currently
7394         # not supported by libtool).
7395         if (for obj in $oldobjs
7396             do
7397               func_basename "$obj"
7398               $ECHO "$func_basename_result"
7399             done | sort | sort -uc >/dev/null 2>&1); then
7400           :
7401         else
7402           $ECHO "copying selected object files to avoid basename conflicts..."
7403           gentop="$output_objdir/${outputname}x"
7404           generated="$generated $gentop"
7405           func_mkdir_p "$gentop"
7406           save_oldobjs=$oldobjs
7407           oldobjs=
7408           counter=1
7409           for obj in $save_oldobjs
7410           do
7411             func_basename "$obj"
7412             objbase="$func_basename_result"
7413             case " $oldobjs " in
7414             " ") oldobjs=$obj ;;
7415             *[\ /]"$objbase "*)
7416               while :; do
7417                 # Make sure we don't pick an alternate name that also
7418                 # overlaps.
7419                 newobj=lt$counter-$objbase
7420                 func_arith $counter + 1
7421                 counter=$func_arith_result
7422                 case " $oldobjs " in
7423                 *[\ /]"$newobj "*) ;;
7424                 *) if test ! -f "$gentop/$newobj"; then break; fi ;;
7425                 esac
7426               done
7427               func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
7428               oldobjs="$oldobjs $gentop/$newobj"
7429               ;;
7430             *) oldobjs="$oldobjs $obj" ;;
7431             esac
7432           done
7433         fi
7434         eval cmds=\"$old_archive_cmds\"
7435
7436         func_len " $cmds"
7437         len=$func_len_result
7438         if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7439           cmds=$old_archive_cmds
7440         else
7441           # the command line is too long to link in one step, link in parts
7442           func_verbose "using piecewise archive linking..."
7443           save_RANLIB=$RANLIB
7444           RANLIB=:
7445           objlist=
7446           concat_cmds=
7447           save_oldobjs=$oldobjs
7448           oldobjs=
7449           # Is there a better way of finding the last object in the list?
7450           for obj in $save_oldobjs
7451           do
7452             last_oldobj=$obj
7453           done
7454           eval test_cmds=\"$old_archive_cmds\"
7455           func_len " $test_cmds"
7456           len0=$func_len_result
7457           len=$len0
7458           for obj in $save_oldobjs
7459           do
7460             func_len " $obj"
7461             func_arith $len + $func_len_result
7462             len=$func_arith_result
7463             func_append objlist " $obj"
7464             if test "$len" -lt "$max_cmd_len"; then
7465               :
7466             else
7467               # the above command should be used before it gets too long
7468               oldobjs=$objlist
7469               if test "$obj" = "$last_oldobj" ; then
7470                 RANLIB=$save_RANLIB
7471               fi
7472               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7473               eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
7474               objlist=
7475               len=$len0
7476             fi
7477           done
7478           RANLIB=$save_RANLIB
7479           oldobjs=$objlist
7480           if test "X$oldobjs" = "X" ; then
7481             eval cmds=\"\$concat_cmds\"
7482           else
7483             eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
7484           fi
7485         fi
7486       fi
7487       func_execute_cmds "$cmds" 'exit $?'
7488     done
7489
7490     test -n "$generated" && \
7491       func_show_eval "${RM}r$generated"
7492
7493     # Now create the libtool archive.
7494     case $output in
7495     *.la)
7496       old_library=
7497       test "$build_old_libs" = yes && old_library="$libname.$libext"
7498       func_verbose "creating $output"
7499
7500       # Preserve any variables that may affect compiler behavior
7501       for var in $variables_saved_for_relink; do
7502         if eval test -z \"\${$var+set}\"; then
7503           relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
7504         elif eval var_value=\$$var; test -z "$var_value"; then
7505           relink_command="$var=; export $var; $relink_command"
7506         else
7507           func_quote_for_eval "$var_value"
7508           relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
7509         fi
7510       done
7511       # Quote the link command for shipping.
7512       relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
7513       relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
7514       if test "$hardcode_automatic" = yes ; then
7515         relink_command=
7516       fi
7517
7518       # Only create the output if not a dry run.
7519       $opt_dry_run || {
7520         for installed in no yes; do
7521           if test "$installed" = yes; then
7522             if test -z "$install_libdir"; then
7523               break
7524             fi
7525             output="$output_objdir/$outputname"i
7526             # Replace all uninstalled libtool libraries with the installed ones
7527             newdependency_libs=
7528             for deplib in $dependency_libs; do
7529               case $deplib in
7530               *.la)
7531                 func_basename "$deplib"
7532                 name="$func_basename_result"
7533                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
7534                 test -z "$libdir" && \
7535                   func_fatal_error "\`$deplib' is not a valid libtool archive"
7536                 newdependency_libs="$newdependency_libs $libdir/$name"
7537                 ;;
7538               *) newdependency_libs="$newdependency_libs $deplib" ;;
7539               esac
7540             done
7541             dependency_libs="$newdependency_libs"
7542             newdlfiles=
7543
7544             for lib in $dlfiles; do
7545               case $lib in
7546               *.la)
7547                 func_basename "$lib"
7548                 name="$func_basename_result"
7549                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
7550                 test -z "$libdir" && \
7551                   func_fatal_error "\`$lib' is not a valid libtool archive"
7552                 newdlfiles="$newdlfiles $libdir/$name"
7553                 ;;
7554               *) newdlfiles="$newdlfiles $lib" ;;
7555               esac
7556             done
7557             dlfiles="$newdlfiles"
7558             newdlprefiles=
7559             for lib in $dlprefiles; do
7560               case $lib in
7561               *.la)
7562                 # Only pass preopened files to the pseudo-archive (for
7563                 # eventual linking with the app. that links it) if we
7564                 # didn't already link the preopened objects directly into
7565                 # the library:
7566                 func_basename "$lib"
7567                 name="$func_basename_result"
7568                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
7569                 test -z "$libdir" && \
7570                   func_fatal_error "\`$lib' is not a valid libtool archive"
7571                 newdlprefiles="$newdlprefiles $libdir/$name"
7572                 ;;
7573               esac
7574             done
7575             dlprefiles="$newdlprefiles"
7576           else
7577             newdlfiles=
7578             for lib in $dlfiles; do
7579               case $lib in
7580                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
7581                 *) abs=`pwd`"/$lib" ;;
7582               esac
7583               newdlfiles="$newdlfiles $abs"
7584             done
7585             dlfiles="$newdlfiles"
7586             newdlprefiles=
7587             for lib in $dlprefiles; do
7588               case $lib in
7589                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
7590                 *) abs=`pwd`"/$lib" ;;
7591               esac
7592               newdlprefiles="$newdlprefiles $abs"
7593             done
7594             dlprefiles="$newdlprefiles"
7595           fi
7596           $RM $output
7597           # place dlname in correct position for cygwin
7598           tdlname=$dlname
7599           case $host,$output,$installed,$module,$dlname in
7600             *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
7601           esac
7602           $ECHO > $output "\
7603 # $outputname - a libtool library file
7604 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
7605 #
7606 # Please DO NOT delete this file!
7607 # It is necessary for linking the library.
7608
7609 # The name that we can dlopen(3).
7610 dlname='$tdlname'
7611
7612 # Names of this library.
7613 library_names='$library_names'
7614
7615 # The name of the static archive.
7616 old_library='$old_library'
7617
7618 # Linker flags that can not go in dependency_libs.
7619 inherited_linker_flags='$new_inherited_linker_flags'
7620
7621 # Libraries that this one depends upon.
7622 dependency_libs='$dependency_libs'
7623
7624 # Names of additional weak libraries provided by this library
7625 weak_library_names='$weak_libs'
7626
7627 # Version information for $libname.
7628 current=$current
7629 age=$age
7630 revision=$revision
7631
7632 # Is this an already installed library?
7633 installed=$installed
7634
7635 # Should we warn about portability when linking against -modules?
7636 shouldnotlink=$module
7637
7638 # Files to dlopen/dlpreopen
7639 dlopen='$dlfiles'
7640 dlpreopen='$dlprefiles'
7641
7642 # Directory that this library needs to be installed in:
7643 libdir='$install_libdir'"
7644           if test "$installed" = no && test "$need_relink" = yes; then
7645             $ECHO >> $output "\
7646 relink_command=\"$relink_command\""
7647           fi
7648         done
7649       }
7650
7651       # Do a symbolic link so that the libtool archive can be found in
7652       # LD_LIBRARY_PATH before the program is installed.
7653       func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
7654       ;;
7655     esac
7656     exit $EXIT_SUCCESS
7657 }
7658
7659 { test "$mode" = link || test "$mode" = relink; } &&
7660     func_mode_link ${1+"$@"}
7661
7662
7663 # func_mode_uninstall arg...
7664 func_mode_uninstall ()
7665 {
7666     $opt_debug
7667     RM="$nonopt"
7668     files=
7669     rmforce=
7670     exit_status=0
7671
7672     # This variable tells wrapper scripts just to set variables rather
7673     # than running their programs.
7674     libtool_install_magic="$magic"
7675
7676     for arg
7677     do
7678       case $arg in
7679       -f) RM="$RM $arg"; rmforce=yes ;;
7680       -*) RM="$RM $arg" ;;
7681       *) files="$files $arg" ;;
7682       esac
7683     done
7684
7685     test -z "$RM" && \
7686       func_fatal_help "you must specify an RM program"
7687
7688     rmdirs=
7689
7690     origobjdir="$objdir"
7691     for file in $files; do
7692       func_dirname "$file" "" "."
7693       dir="$func_dirname_result"
7694       if test "X$dir" = X.; then
7695         objdir="$origobjdir"
7696       else
7697         objdir="$dir/$origobjdir"
7698       fi
7699       func_basename "$file"
7700       name="$func_basename_result"
7701       test "$mode" = uninstall && objdir="$dir"
7702
7703       # Remember objdir for removal later, being careful to avoid duplicates
7704       if test "$mode" = clean; then
7705         case " $rmdirs " in
7706           *" $objdir "*) ;;
7707           *) rmdirs="$rmdirs $objdir" ;;
7708         esac
7709       fi
7710
7711       # Don't error if the file doesn't exist and rm -f was used.
7712       if { test -L "$file"; } >/dev/null 2>&1 ||
7713          { test -h "$file"; } >/dev/null 2>&1 ||
7714          test -f "$file"; then
7715         :
7716       elif test -d "$file"; then
7717         exit_status=1
7718         continue
7719       elif test "$rmforce" = yes; then
7720         continue
7721       fi
7722
7723       rmfiles="$file"
7724
7725       case $name in
7726       *.la)
7727         # Possibly a libtool archive, so verify it.
7728         if func_lalib_p "$file"; then
7729           func_source $dir/$name
7730
7731           # Delete the libtool libraries and symlinks.
7732           for n in $library_names; do
7733             rmfiles="$rmfiles $objdir/$n"
7734           done
7735           test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
7736
7737           case "$mode" in
7738           clean)
7739             case "  $library_names " in
7740             # "  " in the beginning catches empty $dlname
7741             *" $dlname "*) ;;
7742             *) rmfiles="$rmfiles $objdir/$dlname" ;;
7743             esac
7744             test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
7745             ;;
7746           uninstall)
7747             if test -n "$library_names"; then
7748               # Do each command in the postuninstall commands.
7749               func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
7750             fi
7751
7752             if test -n "$old_library"; then
7753               # Do each command in the old_postuninstall commands.
7754               func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
7755             fi
7756             # FIXME: should reinstall the best remaining shared library.
7757             ;;
7758           esac
7759         fi
7760         ;;
7761
7762       *.lo)
7763         # Possibly a libtool object, so verify it.
7764         if func_lalib_p "$file"; then
7765
7766           # Read the .lo file
7767           func_source $dir/$name
7768
7769           # Add PIC object to the list of files to remove.
7770           if test -n "$pic_object" &&
7771              test "$pic_object" != none; then
7772             rmfiles="$rmfiles $dir/$pic_object"
7773           fi
7774
7775           # Add non-PIC object to the list of files to remove.
7776           if test -n "$non_pic_object" &&
7777              test "$non_pic_object" != none; then
7778             rmfiles="$rmfiles $dir/$non_pic_object"
7779           fi
7780         fi
7781         ;;
7782
7783       *)
7784         if test "$mode" = clean ; then
7785           noexename=$name
7786           case $file in
7787           *.exe)
7788             func_stripname '' '.exe' "$file"
7789             file=$func_stripname_result
7790             func_stripname '' '.exe' "$name"
7791             noexename=$func_stripname_result
7792             # $file with .exe has already been added to rmfiles,
7793             # add $file without .exe
7794             rmfiles="$rmfiles $file"
7795             ;;
7796           esac
7797           # Do a test to see if this is a libtool program.
7798           if func_ltwrapper_p "$file"; then
7799             if func_ltwrapper_executable_p "$file"; then
7800               func_ltwrapper_scriptname "$file"
7801               relink_command=
7802               func_source $func_ltwrapper_scriptname_result
7803               rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
7804             else
7805               relink_command=
7806               func_source $dir/$noexename
7807             fi
7808
7809             # note $name still contains .exe if it was in $file originally
7810             # as does the version of $file that was added into $rmfiles
7811             rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
7812             if test "$fast_install" = yes && test -n "$relink_command"; then
7813               rmfiles="$rmfiles $objdir/lt-$name"
7814             fi
7815             if test "X$noexename" != "X$name" ; then
7816               rmfiles="$rmfiles $objdir/lt-${noexename}.c"
7817             fi
7818           fi
7819         fi
7820         ;;
7821       esac
7822       func_show_eval "$RM $rmfiles" 'exit_status=1'
7823     done
7824     objdir="$origobjdir"
7825
7826     # Try to remove the ${objdir}s in the directories where we deleted files
7827     for dir in $rmdirs; do
7828       if test -d "$dir"; then
7829         func_show_eval "rmdir $dir >/dev/null 2>&1"
7830       fi
7831     done
7832
7833     exit $exit_status
7834 }
7835
7836 { test "$mode" = uninstall || test "$mode" = clean; } &&
7837     func_mode_uninstall ${1+"$@"}
7838
7839 test -z "$mode" && {
7840   help="$generic_help"
7841   func_fatal_help "you must specify a MODE"
7842 }
7843
7844 test -z "$exec_cmd" && \
7845   func_fatal_help "invalid operation mode \`$mode'"
7846
7847 if test -n "$exec_cmd"; then
7848   eval exec "$exec_cmd"
7849   exit $EXIT_FAILURE
7850 fi
7851
7852 exit $exit_status
7853
7854
7855 # The TAGs below are defined such that we never get into a situation
7856 # in which we disable both kinds of libraries.  Given conflicting
7857 # choices, we go for a static library, that is the most portable,
7858 # since we can't tell whether shared libraries were disabled because
7859 # the user asked for that or because the platform doesn't support
7860 # them.  This is particularly important on AIX, because we don't
7861 # support having both static and shared libraries enabled at the same
7862 # time on that platform, so we default to a shared-only configuration.
7863 # If a disable-shared tag is given, we'll fallback to a static-only
7864 # configuration.  But we'll never go from static-only to shared-only.
7865
7866 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
7867 build_libtool_libs=no
7868 build_old_libs=yes
7869 # ### END LIBTOOL TAG CONFIG: disable-shared
7870
7871 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
7872 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
7873 # ### END LIBTOOL TAG CONFIG: disable-static
7874
7875 # Local Variables:
7876 # mode:shell-script
7877 # sh-indentation:2
7878 # End:
7879 # vi:sw=2
7880