build-aux/ltmain.sh

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