build-scripts/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
1871     # We need to accept at least all the BSD install flags.
1872     dest=
1873     files=
1874     opts=
1875     prev=
1876     install_type=
1877     isdir=no
1878     stripme=
1879     for arg
1880     do
1881       if test -n "$dest"; then
1882         files="$files $dest"
1883         dest=$arg
1884         continue
1885       fi
1886
1887       case $arg in
1888       -d) isdir=yes ;;
1889       -f)
1890         case " $install_prog " in
1891         *[\\\ /]cp\ *) ;;
1892         *) prev=$arg ;;
1893         esac
1894         ;;
1895       -g | -m | -o)
1896         prev=$arg
1897         ;;
1898       -s)
1899         stripme=" -s"
1900         continue
1901         ;;
1902       -*)
1903         ;;
1904       *)
1905         # If the previous option needed an argument, then skip it.
1906         if test -n "$prev"; then
1907           prev=
1908         else
1909           dest=$arg
1910           continue
1911         fi
1912         ;;
1913       esac
1914
1915       # Aesthetically quote the argument.
1916       func_quote_for_eval "$arg"
1917       install_prog="$install_prog $func_quote_for_eval_result"
1918     done
1919
1920     test -z "$install_prog" && \
1921       func_fatal_help "you must specify an install program"
1922
1923     test -n "$prev" && \
1924       func_fatal_help "the \`$prev' option requires an argument"
1925
1926     if test -z "$files"; then
1927       if test -z "$dest"; then
1928         func_fatal_help "no file or destination specified"
1929       else
1930         func_fatal_help "you must specify a destination"
1931       fi
1932     fi
1933
1934     # Strip any trailing slash from the destination.
1935     func_stripname '' '/' "$dest"
1936     dest=$func_stripname_result
1937
1938     # Check to see that the destination is a directory.
1939     test -d "$dest" && isdir=yes
1940     if test "$isdir" = yes; then
1941       destdir="$dest"
1942       destname=
1943     else
1944       func_dirname_and_basename "$dest" "" "."
1945       destdir="$func_dirname_result"
1946       destname="$func_basename_result"
1947
1948       # Not a directory, so check to see that there is only one file specified.
1949       set dummy $files; shift
1950       test "$#" -gt 1 && \
1951         func_fatal_help "\`$dest' is not a directory"
1952     fi
1953     case $destdir in
1954     [\\/]* | [A-Za-z]:[\\/]*) ;;
1955     *)
1956       for file in $files; do
1957         case $file in
1958         *.lo) ;;
1959         *)
1960           func_fatal_help "\`$destdir' must be an absolute directory name"
1961           ;;
1962         esac
1963       done
1964       ;;
1965     esac
1966
1967     # This variable tells wrapper scripts just to set variables rather
1968     # than running their programs.
1969     libtool_install_magic="$magic"
1970
1971     staticlibs=
1972     future_libdirs=
1973     current_libdirs=
1974     for file in $files; do
1975
1976       # Do each installation.
1977       case $file in
1978       *.$libext)
1979         # Do the static libraries later.
1980         staticlibs="$staticlibs $file"
1981         ;;
1982
1983       *.la)
1984         # Check to see that this really is a libtool archive.
1985         func_lalib_unsafe_p "$file" \
1986           || func_fatal_help "\`$file' is not a valid libtool archive"
1987
1988         library_names=
1989         old_library=
1990         relink_command=
1991         func_source "$file"
1992
1993         # Add the libdir to current_libdirs if it is the destination.
1994         if test "X$destdir" = "X$libdir"; then
1995           case "$current_libdirs " in
1996           *" $libdir "*) ;;
1997           *) current_libdirs="$current_libdirs $libdir" ;;
1998           esac
1999         else
2000           # Note the libdir as a future libdir.
2001           case "$future_libdirs " in
2002           *" $libdir "*) ;;
2003           *) future_libdirs="$future_libdirs $libdir" ;;
2004           esac
2005         fi
2006
2007         func_dirname "$file" "/" ""
2008         dir="$func_dirname_result"
2009         dir="$dir$objdir"
2010
2011         if test -n "$relink_command"; then
2012           # Determine the prefix the user has applied to our future dir.
2013           inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
2014
2015           # Don't allow the user to place us outside of our expected
2016           # location b/c this prevents finding dependent libraries that
2017           # are installed to the same prefix.
2018           # At present, this check doesn't affect windows .dll's that
2019           # are installed into $libdir/../bin (currently, that works fine)
2020           # but it's something to keep an eye on.
2021           test "$inst_prefix_dir" = "$destdir" && \
2022             func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2023
2024           if test -n "$inst_prefix_dir"; then
2025             # Stick the inst_prefix_dir data into the link command.
2026             relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2027           else
2028             relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
2029           fi
2030
2031           func_warning "relinking \`$file'"
2032           func_show_eval "$relink_command" \
2033             'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2034         fi
2035
2036         # See the names of the shared library.
2037         set dummy $library_names; shift
2038         if test -n "$1"; then
2039           realname="$1"
2040           shift
2041
2042           srcname="$realname"
2043           test -n "$relink_command" && srcname="$realname"T
2044
2045           # Install the shared library and build the symlinks.
2046           func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
2047               'exit $?'
2048           tstripme="$stripme"
2049           case $host_os in
2050           cygwin* | mingw* | pw32* | cegcc*)
2051             case $realname in
2052             *.dll.a)
2053               tstripme=""
2054               ;;
2055             esac
2056             ;;
2057           esac
2058           if test -n "$tstripme" && test -n "$striplib"; then
2059             func_show_eval "$striplib $destdir/$realname" 'exit $?'
2060           fi
2061
2062           if test "$#" -gt 0; then
2063             # Delete the old symlinks, and create new ones.
2064             # Try `ln -sf' first, because the `ln' binary might depend on
2065             # the symlink we replace!  Solaris /bin/ln does not understand -f,
2066             # so we also need to try rm && ln -s.
2067             for linkname
2068             do
2069               test "$linkname" != "$realname" \
2070                 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2071             done
2072           fi
2073
2074           # Do each command in the postinstall commands.
2075           lib="$destdir/$realname"
2076           func_execute_cmds "$postinstall_cmds" 'exit $?'
2077         fi
2078
2079         # Install the pseudo-library for information purposes.
2080         func_basename "$file"
2081         name="$func_basename_result"
2082         instname="$dir/$name"i
2083         func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2084
2085         # Maybe install the static library, too.
2086         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2087         ;;
2088
2089       *.lo)
2090         # Install (i.e. copy) a libtool object.
2091
2092         # Figure out destination file name, if it wasn't already specified.
2093         if test -n "$destname"; then
2094           destfile="$destdir/$destname"
2095         else
2096           func_basename "$file"
2097           destfile="$func_basename_result"
2098           destfile="$destdir/$destfile"
2099         fi
2100
2101         # Deduce the name of the destination old-style object file.
2102         case $destfile in
2103         *.lo)
2104           func_lo2o "$destfile"
2105           staticdest=$func_lo2o_result
2106           ;;
2107         *.$objext)
2108           staticdest="$destfile"
2109           destfile=
2110           ;;
2111         *)
2112           func_fatal_help "cannot copy a libtool object to \`$destfile'"
2113           ;;
2114         esac
2115
2116         # Install the libtool object if requested.
2117         test -n "$destfile" && \
2118           func_show_eval "$install_prog $file $destfile" 'exit $?'
2119
2120         # Install the old object if enabled.
2121         if test "$build_old_libs" = yes; then
2122           # Deduce the name of the old-style object file.
2123           func_lo2o "$file"
2124           staticobj=$func_lo2o_result
2125           func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2126         fi
2127         exit $EXIT_SUCCESS
2128         ;;
2129
2130       *)
2131         # Figure out destination file name, if it wasn't already specified.
2132         if test -n "$destname"; then
2133           destfile="$destdir/$destname"
2134         else
2135           func_basename "$file"
2136           destfile="$func_basename_result"
2137           destfile="$destdir/$destfile"
2138         fi
2139
2140         # If the file is missing, and there is a .exe on the end, strip it
2141         # because it is most likely a libtool script we actually want to
2142         # install
2143         stripped_ext=""
2144         case $file in
2145           *.exe)
2146             if test ! -f "$file"; then
2147               func_stripname '' '.exe' "$file"
2148               file=$func_stripname_result
2149               stripped_ext=".exe"
2150             fi
2151             ;;
2152         esac
2153
2154         # Do a test to see if this is really a libtool program.
2155         case $host in
2156         *cygwin* | *mingw*)
2157             if func_ltwrapper_executable_p "$file"; then
2158               func_ltwrapper_scriptname "$file"
2159               wrapper=$func_ltwrapper_scriptname_result
2160             else
2161               func_stripname '' '.exe' "$file"
2162               wrapper=$func_stripname_result
2163             fi
2164             ;;
2165         *)
2166             wrapper=$file
2167             ;;
2168         esac
2169         if func_ltwrapper_script_p "$wrapper"; then
2170           notinst_deplibs=
2171           relink_command=
2172
2173           func_source "$wrapper"
2174
2175           # Check the variables that should have been set.
2176           test -z "$generated_by_libtool_version" && \
2177             func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2178
2179           finalize=yes
2180           for lib in $notinst_deplibs; do
2181             # Check to see that each library is installed.
2182             libdir=
2183             if test -f "$lib"; then
2184               func_source "$lib"
2185             fi
2186             libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
2187             if test -n "$libdir" && test ! -f "$libfile"; then
2188               func_warning "\`$lib' has not been installed in \`$libdir'"
2189               finalize=no
2190             fi
2191           done
2192
2193           relink_command=
2194           func_source "$wrapper"
2195
2196           outputname=
2197           if test "$fast_install" = no && test -n "$relink_command"; then
2198             $opt_dry_run || {
2199               if test "$finalize" = yes; then
2200                 tmpdir=`func_mktempdir`
2201                 func_basename "$file$stripped_ext"
2202                 file="$func_basename_result"
2203                 outputname="$tmpdir/$file"
2204                 # Replace the output file specification.
2205                 relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
2206
2207                 $opt_silent || {
2208                   func_quote_for_expand "$relink_command"
2209                   eval "func_echo $func_quote_for_expand_result"
2210                 }
2211                 if eval "$relink_command"; then :
2212                   else
2213                   func_error "error: relink \`$file' with the above command before installing it"
2214                   $opt_dry_run || ${RM}r "$tmpdir"
2215                   continue
2216                 fi
2217                 file="$outputname"
2218               else
2219                 func_warning "cannot relink \`$file'"
2220               fi
2221             }
2222           else
2223             # Install the binary that we compiled earlier.
2224             file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
2225           fi
2226         fi
2227
2228         # remove .exe since cygwin /usr/bin/install will append another
2229         # one anyway
2230         case $install_prog,$host in
2231         */usr/bin/install*,*cygwin*)
2232           case $file:$destfile in
2233           *.exe:*.exe)
2234             # this is ok
2235             ;;
2236           *.exe:*)
2237             destfile=$destfile.exe
2238             ;;
2239           *:*.exe)
2240             func_stripname '' '.exe' "$destfile"
2241             destfile=$func_stripname_result
2242             ;;
2243           esac
2244           ;;
2245         esac
2246         func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2247         $opt_dry_run || if test -n "$outputname"; then
2248           ${RM}r "$tmpdir"
2249         fi
2250         ;;
2251       esac
2252     done
2253
2254     for file in $staticlibs; do
2255       func_basename "$file"
2256       name="$func_basename_result"
2257
2258       # Set up the ranlib parameters.
2259       oldlib="$destdir/$name"
2260
2261       func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2262
2263       if test -n "$stripme" && test -n "$old_striplib"; then
2264         func_show_eval "$old_striplib $oldlib" 'exit $?'
2265       fi
2266
2267       # Do each command in the postinstall commands.
2268       func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2269     done
2270
2271     test -n "$future_libdirs" && \
2272       func_warning "remember to run \`$progname --finish$future_libdirs'"
2273
2274     if test -n "$current_libdirs"; then
2275       # Maybe just do a dry run.
2276       $opt_dry_run && current_libdirs=" -n$current_libdirs"
2277       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2278     else
2279       exit $EXIT_SUCCESS
2280     fi
2281 }
2282
2283 test "$mode" = install && func_mode_install ${1+"$@"}
2284
2285
2286 # func_generate_dlsyms outputname originator pic_p
2287 # Extract symbols from dlprefiles and create ${outputname}S.o with
2288 # a dlpreopen symbol table.
2289 func_generate_dlsyms ()
2290 {
2291     $opt_debug
2292     my_outputname="$1"
2293     my_originator="$2"
2294     my_pic_p="${3-no}"
2295     my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
2296     my_dlsyms=
2297
2298     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2299       if test -n "$NM" && test -n "$global_symbol_pipe"; then
2300         my_dlsyms="${my_outputname}S.c"
2301       else
2302         func_error "not configured to extract global symbols from dlpreopened files"
2303       fi
2304     fi
2305
2306     if test -n "$my_dlsyms"; then
2307       case $my_dlsyms in
2308       "") ;;
2309       *.c)
2310         # Discover the nlist of each of the dlfiles.
2311         nlist="$output_objdir/${my_outputname}.nm"
2312
2313         func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2314
2315         # Parse the name list into a source file.
2316         func_verbose "creating $output_objdir/$my_dlsyms"
2317
2318         $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
2319 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2320 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2321
2322 #ifdef __cplusplus
2323 extern \"C\" {
2324 #endif
2325
2326 /* External symbol declarations for the compiler. */\
2327 "
2328
2329         if test "$dlself" = yes; then
2330           func_verbose "generating symbol list for \`$output'"
2331
2332           $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2333
2334           # Add our own program objects to the symbol list.
2335           progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2336           for progfile in $progfiles; do
2337             func_verbose "extracting global C symbols from \`$progfile'"
2338             $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
2339           done
2340
2341           if test -n "$exclude_expsyms"; then
2342             $opt_dry_run || {
2343               eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
2344               eval '$MV "$nlist"T "$nlist"'
2345             }
2346           fi
2347
2348           if test -n "$export_symbols_regex"; then
2349             $opt_dry_run || {
2350               eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
2351               eval '$MV "$nlist"T "$nlist"'
2352             }
2353           fi
2354
2355           # Prepare the list of exported symbols
2356           if test -z "$export_symbols"; then
2357             export_symbols="$output_objdir/$outputname.exp"
2358             $opt_dry_run || {
2359               $RM $export_symbols
2360               eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
2361               case $host in
2362               *cygwin* | *mingw* | *cegcc* )
2363                 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2364                 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
2365                 ;;
2366               esac
2367             }
2368           else
2369             $opt_dry_run || {
2370               eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
2371               eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
2372               eval '$MV "$nlist"T "$nlist"'
2373               case $host in
2374                 *cygwin | *mingw* | *cegcc* )
2375                   eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2376                   eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
2377                   ;;
2378               esac
2379             }
2380           fi
2381         fi
2382
2383         for dlprefile in $dlprefiles; do
2384           func_verbose "extracting global C symbols from \`$dlprefile'"
2385           func_basename "$dlprefile"
2386           name="$func_basename_result"
2387           $opt_dry_run || {
2388             eval '$ECHO ": $name " >> "$nlist"'
2389             eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2390           }
2391         done
2392
2393         $opt_dry_run || {
2394           # Make sure we have at least an empty file.
2395           test -f "$nlist" || : > "$nlist"
2396
2397           if test -n "$exclude_expsyms"; then
2398             $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2399             $MV "$nlist"T "$nlist"
2400           fi
2401
2402           # Try sorting and uniquifying the output.
2403           if $GREP -v "^: " < "$nlist" |
2404               if sort -k 3 </dev/null >/dev/null 2>&1; then
2405                 sort -k 3
2406               else
2407                 sort +2
2408               fi |
2409               uniq > "$nlist"S; then
2410             :
2411           else
2412             $GREP -v "^: " < "$nlist" > "$nlist"S
2413           fi
2414
2415           if test -f "$nlist"S; then
2416             eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2417           else
2418             $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
2419           fi
2420
2421           $ECHO >> "$output_objdir/$my_dlsyms" "\
2422
2423 /* The mapping between symbol names and symbols.  */
2424 typedef struct {
2425   const char *name;
2426   void *address;
2427 } lt_dlsymlist;
2428 "
2429           case $host in
2430           *cygwin* | *mingw* | *cegcc* )
2431             $ECHO >> "$output_objdir/$my_dlsyms" "\
2432 /* DATA imports from DLLs on WIN32 con't be const, because
2433    runtime relocations are performed -- see ld's documentation
2434    on pseudo-relocs.  */"
2435             lt_dlsym_const= ;;
2436           *osf5*)
2437             echo >> "$output_objdir/$my_dlsyms" "\
2438 /* This system does not cope well with relocations in const data */"
2439             lt_dlsym_const= ;;
2440           *)
2441             lt_dlsym_const=const ;;
2442           esac
2443
2444           $ECHO >> "$output_objdir/$my_dlsyms" "\
2445 extern $lt_dlsym_const lt_dlsymlist
2446 lt_${my_prefix}_LTX_preloaded_symbols[];
2447 $lt_dlsym_const lt_dlsymlist
2448 lt_${my_prefix}_LTX_preloaded_symbols[] =
2449 {\
2450   { \"$my_originator\", (void *) 0 },"
2451
2452           case $need_lib_prefix in
2453           no)
2454             eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2455             ;;
2456           *)
2457             eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2458             ;;
2459           esac
2460           $ECHO >> "$output_objdir/$my_dlsyms" "\
2461   {0, (void *) 0}
2462 };
2463
2464 /* This works around a problem in FreeBSD linker */
2465 #ifdef FREEBSD_WORKAROUND
2466 static const void *lt_preloaded_setup() {
2467   return lt_${my_prefix}_LTX_preloaded_symbols;
2468 }
2469 #endif
2470
2471 #ifdef __cplusplus
2472 }
2473 #endif\
2474 "
2475         } # !$opt_dry_run
2476
2477         pic_flag_for_symtable=
2478         case "$compile_command " in
2479         *" -static "*) ;;
2480         *)
2481           case $host in
2482           # compiling the symbol table file with pic_flag works around
2483           # a FreeBSD bug that causes programs to crash when -lm is
2484           # linked before any other PIC object.  But we must not use
2485           # pic_flag when linking with -static.  The problem exists in
2486           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2487           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2488             pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2489           *-*-hpux*)
2490             pic_flag_for_symtable=" $pic_flag"  ;;
2491           *)
2492             if test "X$my_pic_p" != Xno; then
2493               pic_flag_for_symtable=" $pic_flag"
2494             fi
2495             ;;
2496           esac
2497           ;;
2498         esac
2499         symtab_cflags=
2500         for arg in $LTCFLAGS; do
2501           case $arg in
2502           -pie | -fpie | -fPIE) ;;
2503           *) symtab_cflags="$symtab_cflags $arg" ;;
2504           esac
2505         done
2506
2507         # Now compile the dynamic symbol file.
2508         func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
2509
2510         # Clean up the generated files.
2511         func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
2512
2513         # Transform the symbol file into the correct name.
2514         symfileobj="$output_objdir/${my_outputname}S.$objext"
2515         case $host in
2516         *cygwin* | *mingw* | *cegcc* )
2517           if test -f "$output_objdir/$my_outputname.def"; then
2518             compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2519             finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2520           else
2521             compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2522             finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2523           fi
2524           ;;
2525         *)
2526           compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2527           finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2528           ;;
2529         esac
2530         ;;
2531       *)
2532         func_fatal_error "unknown suffix for \`$my_dlsyms'"
2533         ;;
2534       esac
2535     else
2536       # We keep going just in case the user didn't refer to
2537       # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
2538       # really was required.
2539
2540       # Nullify the symbol file.
2541       compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
2542       finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
2543     fi
2544 }
2545
2546 # func_win32_libid arg
2547 # return the library type of file 'arg'
2548 #
2549 # Need a lot of goo to handle *both* DLLs and import libs
2550 # Has to be a shell function in order to 'eat' the argument
2551 # that is supplied when $file_magic_command is called.
2552 func_win32_libid ()
2553 {
2554   $opt_debug
2555   win32_libid_type="unknown"
2556   win32_fileres=`file -L $1 2>/dev/null`
2557   case $win32_fileres in
2558   *ar\ archive\ import\ library*) # definitely import
2559     win32_libid_type="x86 archive import"
2560     ;;
2561   *ar\ archive*) # could be an import, or static
2562     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
2563        $EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
2564       win32_nmres=`eval $NM -f posix -A $1 |
2565         $SED -n -e '
2566             1,100{
2567                 / I /{
2568                     s,.*,import,
2569                     p
2570                     q
2571                 }
2572             }'`
2573       case $win32_nmres in
2574       import*)  win32_libid_type="x86 archive import";;
2575       *)        win32_libid_type="x86 archive static";;
2576       esac
2577     fi
2578     ;;
2579   *DLL*)
2580     win32_libid_type="x86 DLL"
2581     ;;
2582   *executable*) # but shell scripts are "executable" too...
2583     case $win32_fileres in
2584     *MS\ Windows\ PE\ Intel*)
2585       win32_libid_type="x86 DLL"
2586       ;;
2587     esac
2588     ;;
2589   esac
2590   $ECHO "$win32_libid_type"
2591 }
2592
2593
2594
2595 # func_extract_an_archive dir oldlib
2596 func_extract_an_archive ()
2597 {
2598     $opt_debug
2599     f_ex_an_ar_dir="$1"; shift
2600     f_ex_an_ar_oldlib="$1"
2601     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
2602     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
2603      :
2604     else
2605       func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
2606     fi
2607 }
2608
2609
2610 # func_extract_archives gentop oldlib ...
2611 func_extract_archives ()
2612 {
2613     $opt_debug
2614     my_gentop="$1"; shift
2615     my_oldlibs=${1+"$@"}
2616     my_oldobjs=""
2617     my_xlib=""
2618     my_xabs=""
2619     my_xdir=""
2620
2621     for my_xlib in $my_oldlibs; do
2622       # Extract the objects.
2623       case $my_xlib in
2624         [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
2625         *) my_xabs=`pwd`"/$my_xlib" ;;
2626       esac
2627       func_basename "$my_xlib"
2628       my_xlib="$func_basename_result"
2629       my_xlib_u=$my_xlib
2630       while :; do
2631         case " $extracted_archives " in
2632         *" $my_xlib_u "*)
2633           func_arith $extracted_serial + 1
2634           extracted_serial=$func_arith_result
2635           my_xlib_u=lt$extracted_serial-$my_xlib ;;
2636         *) break ;;
2637         esac
2638       done
2639       extracted_archives="$extracted_archives $my_xlib_u"
2640       my_xdir="$my_gentop/$my_xlib_u"
2641
2642       func_mkdir_p "$my_xdir"
2643
2644       case $host in
2645       *-darwin*)
2646         func_verbose "Extracting $my_xabs"
2647         # Do not bother doing anything if just a dry run
2648         $opt_dry_run || {
2649           darwin_orig_dir=`pwd`
2650           cd $my_xdir || exit $?
2651           darwin_archive=$my_xabs
2652           darwin_curdir=`pwd`
2653           darwin_base_archive=`basename "$darwin_archive"`
2654           darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
2655           if test -n "$darwin_arches"; then
2656             darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
2657             darwin_arch=
2658             func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
2659             for darwin_arch in  $darwin_arches ; do
2660               func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2661               $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
2662               cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2663               func_extract_an_archive "`pwd`" "${darwin_base_archive}"
2664               cd "$darwin_curdir"
2665               $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
2666             done # $darwin_arches
2667             ## Okay now we've a bunch of thin objects, gotta fatten them up :)
2668             darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
2669             darwin_file=
2670             darwin_files=
2671             for darwin_file in $darwin_filelist; do
2672               darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
2673               $LIPO -create -output "$darwin_file" $darwin_files
2674             done # $darwin_filelist
2675             $RM -rf unfat-$$
2676             cd "$darwin_orig_dir"
2677           else
2678             cd $darwin_orig_dir
2679             func_extract_an_archive "$my_xdir" "$my_xabs"
2680           fi # $darwin_arches
2681         } # !$opt_dry_run
2682         ;;
2683       *)
2684         func_extract_an_archive "$my_xdir" "$my_xabs"
2685         ;;
2686       esac
2687       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
2688     done
2689
2690     func_extract_archives_result="$my_oldobjs"
2691 }
2692
2693
2694
2695 # func_emit_wrapper_part1 [arg=no]
2696 #
2697 # Emit the first part of a libtool wrapper script on stdout.
2698 # For more information, see the description associated with
2699 # func_emit_wrapper(), below.
2700 func_emit_wrapper_part1 ()
2701 {
2702         func_emit_wrapper_part1_arg1=no
2703         if test -n "$1" ; then
2704           func_emit_wrapper_part1_arg1=$1
2705         fi
2706
2707         $ECHO "\
2708 #! $SHELL
2709
2710 # $output - temporary wrapper script for $objdir/$outputname
2711 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
2712 #
2713 # The $output program cannot be directly executed until all the libtool
2714 # libraries that it depends on are installed.
2715 #
2716 # This wrapper script should never be moved out of the build directory.
2717 # If it is, it will not operate correctly.
2718
2719 # Sed substitution that helps us do robust quoting.  It backslashifies
2720 # metacharacters that are still active within double-quoted strings.
2721 Xsed='${SED} -e 1s/^X//'
2722 sed_quote_subst='$sed_quote_subst'
2723
2724 # Be Bourne compatible
2725 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
2726   emulate sh
2727   NULLCMD=:
2728   # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
2729   # is contrary to our usage.  Disable this feature.
2730   alias -g '\${1+\"\$@\"}'='\"\$@\"'
2731   setopt NO_GLOB_SUBST
2732 else
2733   case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
2734 fi
2735 BIN_SH=xpg4; export BIN_SH # for Tru64
2736 DUALCASE=1; export DUALCASE # for MKS sh
2737
2738 # The HP-UX ksh and POSIX shell print the target directory to stdout
2739 # if CDPATH is set.
2740 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
2741
2742 relink_command=\"$relink_command\"
2743
2744 # This environment variable determines our operation mode.
2745 if test \"\$libtool_install_magic\" = \"$magic\"; then
2746   # install mode needs the following variables:
2747   generated_by_libtool_version='$macro_version'
2748   notinst_deplibs='$notinst_deplibs'
2749 else
2750   # When we are sourced in execute mode, \$file and \$ECHO are already set.
2751   if test \"\$libtool_execute_magic\" != \"$magic\"; then
2752     ECHO=\"$qecho\"
2753     file=\"\$0\"
2754     # Make sure echo works.
2755     if test \"X\$1\" = X--no-reexec; then
2756       # Discard the --no-reexec flag, and continue.
2757       shift
2758     elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
2759       # Yippee, \$ECHO works!
2760       :
2761     else
2762       # Restart under the correct shell, and then maybe \$ECHO will work.
2763       exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
2764     fi
2765   fi\
2766 "
2767         $ECHO "\
2768
2769   # Find the directory that this script lives in.
2770   thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
2771   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
2772
2773   # Follow symbolic links until we get to the real thisdir.
2774   file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
2775   while test -n \"\$file\"; do
2776     destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
2777
2778     # If there was a directory component, then change thisdir.
2779     if test \"x\$destdir\" != \"x\$file\"; then
2780       case \"\$destdir\" in
2781       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
2782       *) thisdir=\"\$thisdir/\$destdir\" ;;
2783       esac
2784     fi
2785
2786     file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
2787     file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
2788   done
2789 "
2790 }
2791 # end: func_emit_wrapper_part1
2792
2793 # func_emit_wrapper_part2 [arg=no]
2794 #
2795 # Emit the second part of a libtool wrapper script on stdout.
2796 # For more information, see the description associated with
2797 # func_emit_wrapper(), below.
2798 func_emit_wrapper_part2 ()
2799 {
2800         func_emit_wrapper_part2_arg1=no
2801         if test -n "$1" ; then
2802           func_emit_wrapper_part2_arg1=$1
2803         fi
2804
2805         $ECHO "\
2806
2807   # Usually 'no', except on cygwin/mingw when embedded into
2808   # the cwrapper.
2809   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
2810   if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
2811     # special case for '.'
2812     if test \"\$thisdir\" = \".\"; then
2813       thisdir=\`pwd\`
2814     fi
2815     # remove .libs from thisdir
2816     case \"\$thisdir\" in
2817     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
2818     $objdir )   thisdir=. ;;
2819     esac
2820   fi
2821
2822   # Try to get the absolute directory name.
2823   absdir=\`cd \"\$thisdir\" && pwd\`
2824   test -n \"\$absdir\" && thisdir=\"\$absdir\"
2825 "
2826
2827         if test "$fast_install" = yes; then
2828           $ECHO "\
2829   program=lt-'$outputname'$exeext
2830   progdir=\"\$thisdir/$objdir\"
2831
2832   if test ! -f \"\$progdir/\$program\" ||
2833      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
2834        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
2835
2836     file=\"\$\$-\$program\"
2837
2838     if test ! -d \"\$progdir\"; then
2839       $MKDIR \"\$progdir\"
2840     else
2841       $RM \"\$progdir/\$file\"
2842     fi"
2843
2844           $ECHO "\
2845
2846     # relink executable if necessary
2847     if test -n \"\$relink_command\"; then
2848       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
2849       else
2850         $ECHO \"\$relink_command_output\" >&2
2851         $RM \"\$progdir/\$file\"
2852         exit 1
2853       fi
2854     fi
2855
2856     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
2857     { $RM \"\$progdir/\$program\";
2858       $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
2859     $RM \"\$progdir/\$file\"
2860   fi"
2861         else
2862           $ECHO "\
2863   program='$outputname'
2864   progdir=\"\$thisdir/$objdir\"
2865 "
2866         fi
2867
2868         $ECHO "\
2869
2870   if test -f \"\$progdir/\$program\"; then"
2871
2872         # Export our shlibpath_var if we have one.
2873         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
2874           $ECHO "\
2875     # Add our own library path to $shlibpath_var
2876     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
2877
2878     # Some systems cannot cope with colon-terminated $shlibpath_var
2879     # The second colon is a workaround for a bug in BeOS R4 sed
2880     $shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
2881
2882     export $shlibpath_var
2883 "
2884         fi
2885
2886         # fixup the dll searchpath if we need to.
2887         if test -n "$dllsearchpath"; then
2888           $ECHO "\
2889     # Add the dll search path components to the executable PATH
2890     PATH=$dllsearchpath:\$PATH
2891 "
2892         fi
2893
2894         $ECHO "\
2895     if test \"\$libtool_execute_magic\" != \"$magic\"; then
2896       # Run the actual program with our arguments.
2897 "
2898         case $host in
2899         # Backslashes separate directories on plain windows
2900         *-*-mingw | *-*-os2* | *-cegcc*)
2901           $ECHO "\
2902       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
2903 "
2904           ;;
2905
2906         *)
2907           $ECHO "\
2908       exec \"\$progdir/\$program\" \${1+\"\$@\"}
2909 "
2910           ;;
2911         esac
2912         $ECHO "\
2913       \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
2914       exit 1
2915     fi
2916   else
2917     # The program doesn't exist.
2918     \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
2919     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
2920     $ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
2921     exit 1
2922   fi
2923 fi\
2924 "
2925 }
2926 # end: func_emit_wrapper_part2
2927
2928
2929 # func_emit_wrapper [arg=no]
2930 #
2931 # Emit a libtool wrapper script on stdout.
2932 # Don't directly open a file because we may want to
2933 # incorporate the script contents within a cygwin/mingw
2934 # wrapper executable.  Must ONLY be called from within
2935 # func_mode_link because it depends on a number of variables
2936 # set therein.
2937 #
2938 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
2939 # variable will take.  If 'yes', then the emitted script
2940 # will assume that the directory in which it is stored is
2941 # the $objdir directory.  This is a cygwin/mingw-specific
2942 # behavior.
2943 func_emit_wrapper ()
2944 {
2945         func_emit_wrapper_arg1=no
2946         if test -n "$1" ; then
2947           func_emit_wrapper_arg1=$1
2948         fi
2949
2950         # split this up so that func_emit_cwrapperexe_src
2951         # can call each part independently.
2952         func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"
2953         func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"
2954 }
2955
2956
2957 # func_to_host_path arg
2958 #
2959 # Convert paths to host format when used with build tools.
2960 # Intended for use with "native" mingw (where libtool itself
2961 # is running under the msys shell), or in the following cross-
2962 # build environments:
2963 #    $build          $host
2964 #    mingw (msys)    mingw  [e.g. native]
2965 #    cygwin          mingw
2966 #    *nix + wine     mingw
2967 # where wine is equipped with the `winepath' executable.
2968 # In the native mingw case, the (msys) shell automatically
2969 # converts paths for any non-msys applications it launches,
2970 # but that facility isn't available from inside the cwrapper.
2971 # Similar accommodations are necessary for $host mingw and
2972 # $build cygwin.  Calling this function does no harm for other
2973 # $host/$build combinations not listed above.
2974 #
2975 # ARG is the path (on $build) that should be converted to
2976 # the proper representation for $host. The result is stored
2977 # in $func_to_host_path_result.
2978 func_to_host_path ()
2979 {
2980   func_to_host_path_result="$1"
2981   if test -n "$1" ; then
2982     case $host in
2983       *mingw* )
2984         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
2985         case $build in
2986           *mingw* ) # actually, msys
2987             # awkward: cmd appends spaces to result
2988             lt_sed_strip_trailing_spaces="s/[ ]*\$//"
2989             func_to_host_path_tmp1=`( cmd //c echo "$1" |\
2990               $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
2991             func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
2992               $SED -e "$lt_sed_naive_backslashify"`
2993             ;;
2994           *cygwin* )
2995             func_to_host_path_tmp1=`cygpath -w "$1"`
2996             func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
2997               $SED -e "$lt_sed_naive_backslashify"`
2998             ;;
2999           * )
3000             # Unfortunately, winepath does not exit with a non-zero
3001             # error code, so we are forced to check the contents of
3002             # stdout. On the other hand, if the command is not
3003             # found, the shell will set an exit code of 127 and print
3004             # *an error message* to stdout. So we must check for both
3005             # error code of zero AND non-empty stdout, which explains
3006             # the odd construction:
3007             func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
3008             if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
3009               func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3010                 $SED -e "$lt_sed_naive_backslashify"`
3011             else
3012               # Allow warning below.
3013               func_to_host_path_result=""
3014             fi
3015             ;;
3016         esac
3017         if test -z "$func_to_host_path_result" ; then
3018           #func_error "Could not determine host path corresponding to"
3019           #func_error "  '$1'"
3020           #func_error "Continuing, but uninstalled executables may not work."
3021           # Fallback:
3022           func_to_host_path_result="$1"
3023         fi
3024         ;;
3025     esac
3026   fi
3027 }
3028 # end: func_to_host_path
3029
3030 # func_to_host_pathlist arg
3031 #
3032 # Convert pathlists to host format when used with build tools.
3033 # See func_to_host_path(), above. This function supports the
3034 # following $build/$host combinations (but does no harm for
3035 # combinations not listed here):
3036 #    $build          $host
3037 #    mingw (msys)    mingw  [e.g. native]
3038 #    cygwin          mingw
3039 #    *nix + wine     mingw
3040 #
3041 # Path separators are also converted from $build format to
3042 # $host format. If ARG begins or ends with a path separator
3043 # character, it is preserved (but converted to $host format)
3044 # on output.
3045 #
3046 # ARG is a pathlist (on $build) that should be converted to
3047 # the proper representation on $host. The result is stored
3048 # in $func_to_host_pathlist_result.
3049 func_to_host_pathlist ()
3050 {
3051   func_to_host_pathlist_result="$1"
3052   if test -n "$1" ; then
3053     case $host in
3054       *mingw* )
3055         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3056         # Remove leading and trailing path separator characters from
3057         # ARG. msys behavior is inconsistent here, cygpath turns them
3058         # into '.;' and ';.', and winepath ignores them completely.
3059         func_to_host_pathlist_tmp2="$1"
3060         # Once set for this call, this variable should not be
3061         # reassigned. It is used in tha fallback case.
3062         func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\
3063           $SED -e 's|^:*||' -e 's|:*$||'`
3064         case $build in
3065           *mingw* ) # Actually, msys.
3066             # Awkward: cmd appends spaces to result.
3067             lt_sed_strip_trailing_spaces="s/[ ]*\$//"
3068             func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\
3069               $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
3070             func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3071               $SED -e "$lt_sed_naive_backslashify"`
3072             ;;
3073           *cygwin* )
3074             func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`
3075             func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3076               $SED -e "$lt_sed_naive_backslashify"`
3077             ;;
3078           * )
3079             # unfortunately, winepath doesn't convert pathlists
3080             func_to_host_pathlist_result=""
3081             func_to_host_pathlist_oldIFS=$IFS
3082             IFS=:
3083             for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
3084               IFS=$func_to_host_pathlist_oldIFS
3085               if test -n "$func_to_host_pathlist_f" ; then
3086                 func_to_host_path "$func_to_host_pathlist_f"
3087                 if test -n "$func_to_host_path_result" ; then
3088                   if test -z "$func_to_host_pathlist_result" ; then
3089                     func_to_host_pathlist_result="$func_to_host_path_result"
3090                   else
3091                     func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"
3092                   fi
3093                 fi
3094               fi
3095               IFS=:
3096             done
3097             IFS=$func_to_host_pathlist_oldIFS
3098             ;;
3099         esac
3100         if test -z "$func_to_host_pathlist_result" ; then
3101           func_error "Could not determine the host path(s) corresponding to"
3102           func_error "  '$1'"
3103           func_error "Continuing, but uninstalled executables may not work."
3104           # Fallback. This may break if $1 contains DOS-style drive
3105           # specifications. The fix is not to complicate the expression
3106           # below, but for the user to provide a working wine installation
3107           # with winepath so that path translation in the cross-to-mingw
3108           # case works properly.
3109           lt_replace_pathsep_nix_to_dos="s|:|;|g"
3110           func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
3111             $SED -e "$lt_replace_pathsep_nix_to_dos"`
3112         fi
3113         # Now, add the leading and trailing path separators back
3114         case "$1" in
3115           :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
3116             ;;
3117         esac
3118         case "$1" in
3119           *: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"
3120             ;;
3121         esac
3122         ;;
3123     esac
3124   fi
3125 }
3126 # end: func_to_host_pathlist
3127
3128 # func_emit_cwrapperexe_src
3129 # emit the source code for a wrapper executable on stdout
3130 # Must ONLY be called from within func_mode_link because
3131 # it depends on a number of variable set therein.
3132 func_emit_cwrapperexe_src ()
3133 {
3134         cat <<EOF
3135
3136 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
3137    Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3138
3139    The $output program cannot be directly executed until all the libtool
3140    libraries that it depends on are installed.
3141
3142    This wrapper executable should never be moved out of the build directory.
3143    If it is, it will not operate correctly.
3144
3145    Currently, it simply execs the wrapper *script* "$SHELL $output",
3146    but could eventually absorb all of the scripts functionality and
3147    exec $objdir/$outputname directly.
3148 */
3149 EOF
3150             cat <<"EOF"
3151 #include <stdio.h>
3152 #include <stdlib.h>
3153 #ifdef _MSC_VER
3154 # include <direct.h>
3155 # include <process.h>
3156 # include <io.h>
3157 # define setmode _setmode
3158 #else
3159 # include <unistd.h>
3160 # include <stdint.h>
3161 # ifdef __CYGWIN__
3162 #  include <io.h>
3163 #  define HAVE_SETENV
3164 #  ifdef __STRICT_ANSI__
3165 char *realpath (const char *, char *);
3166 int putenv (char *);
3167 int setenv (const char *, const char *, int);
3168 #  endif
3169 # endif
3170 #endif
3171 #include <malloc.h>
3172 #include <stdarg.h>
3173 #include <assert.h>
3174 #include <string.h>
3175 #include <ctype.h>
3176 #include <errno.h>
3177 #include <fcntl.h>
3178 #include <sys/stat.h>
3179
3180 #if defined(PATH_MAX)
3181 # define LT_PATHMAX PATH_MAX
3182 #elif defined(MAXPATHLEN)
3183 # define LT_PATHMAX MAXPATHLEN
3184 #else
3185 # define LT_PATHMAX 1024
3186 #endif
3187
3188 #ifndef S_IXOTH
3189 # define S_IXOTH 0
3190 #endif
3191 #ifndef S_IXGRP
3192 # define S_IXGRP 0
3193 #endif
3194
3195 #ifdef _MSC_VER
3196 # define S_IXUSR _S_IEXEC
3197 # define stat _stat
3198 # ifndef _INTPTR_T_DEFINED
3199 #  define intptr_t int
3200 # endif
3201 #endif
3202
3203 #ifndef DIR_SEPARATOR
3204 # define DIR_SEPARATOR '/'
3205 # define PATH_SEPARATOR ':'
3206 #endif
3207
3208 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
3209   defined (__OS2__)
3210 # define HAVE_DOS_BASED_FILE_SYSTEM
3211 # define FOPEN_WB "wb"
3212 # ifndef DIR_SEPARATOR_2
3213 #  define DIR_SEPARATOR_2 '\\'
3214 # endif
3215 # ifndef PATH_SEPARATOR_2
3216 #  define PATH_SEPARATOR_2 ';'
3217 # endif
3218 #endif
3219
3220 #ifndef DIR_SEPARATOR_2
3221 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3222 #else /* DIR_SEPARATOR_2 */
3223 # define IS_DIR_SEPARATOR(ch) \
3224         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
3225 #endif /* DIR_SEPARATOR_2 */
3226
3227 #ifndef PATH_SEPARATOR_2
3228 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3229 #else /* PATH_SEPARATOR_2 */
3230 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3231 #endif /* PATH_SEPARATOR_2 */
3232
3233 #ifdef __CYGWIN__
3234 # define FOPEN_WB "wb"
3235 #endif
3236
3237 #ifndef FOPEN_WB
3238 # define FOPEN_WB "w"
3239 #endif
3240 #ifndef _O_BINARY
3241 # define _O_BINARY 0
3242 #endif
3243
3244 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
3245 #define XFREE(stale) do { \
3246   if (stale) { free ((void *) stale); stale = 0; } \
3247 } while (0)
3248
3249 #undef LTWRAPPER_DEBUGPRINTF
3250 #if defined DEBUGWRAPPER
3251 # define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3252 static void
3253 ltwrapper_debugprintf (const char *fmt, ...)
3254 {
3255     va_list args;
3256     va_start (args, fmt);
3257     (void) vfprintf (stderr, fmt, args);
3258     va_end (args);
3259 }
3260 #else
3261 # define LTWRAPPER_DEBUGPRINTF(args)
3262 #endif
3263
3264 const char *program_name = NULL;
3265
3266 void *xmalloc (size_t num);
3267 char *xstrdup (const char *string);
3268 const char *base_name (const char *name);
3269 char *find_executable (const char *wrapper);
3270 char *chase_symlinks (const char *pathspec);
3271 int make_executable (const char *path);
3272 int check_executable (const char *path);
3273 char *strendzap (char *str, const char *pat);
3274 void lt_fatal (const char *message, ...);
3275 void lt_setenv (const char *name, const char *value);
3276 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
3277 void lt_opt_process_env_set (const char *arg);
3278 void lt_opt_process_env_prepend (const char *arg);
3279 void lt_opt_process_env_append (const char *arg);
3280 int lt_split_name_value (const char *arg, char** name, char** value);
3281 void lt_update_exe_path (const char *name, const char *value);
3282 void lt_update_lib_path (const char *name, const char *value);
3283
3284 static const char *script_text_part1 =
3285 EOF
3286
3287             func_emit_wrapper_part1 yes |
3288                 $SED -e 's/\([\\"]\)/\\\1/g' \
3289                      -e 's/^/  "/' -e 's/$/\\n"/'
3290             echo ";"
3291             cat <<EOF
3292
3293 static const char *script_text_part2 =
3294 EOF
3295             func_emit_wrapper_part2 yes |
3296                 $SED -e 's/\([\\"]\)/\\\1/g' \
3297                      -e 's/^/  "/' -e 's/$/\\n"/'
3298             echo ";"
3299
3300             cat <<EOF
3301 const char * MAGIC_EXE = "$magic_exe";
3302 const char * LIB_PATH_VARNAME = "$shlibpath_var";
3303 EOF
3304
3305             if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3306               func_to_host_pathlist "$temp_rpath"
3307               cat <<EOF
3308 const char * LIB_PATH_VALUE   = "$func_to_host_pathlist_result";
3309 EOF
3310             else
3311               cat <<"EOF"
3312 const char * LIB_PATH_VALUE   = "";
3313 EOF
3314             fi
3315
3316             if test -n "$dllsearchpath"; then
3317               func_to_host_pathlist "$dllsearchpath:"
3318               cat <<EOF
3319 const char * EXE_PATH_VARNAME = "PATH";
3320 const char * EXE_PATH_VALUE   = "$func_to_host_pathlist_result";
3321 EOF
3322             else
3323               cat <<"EOF"
3324 const char * EXE_PATH_VARNAME = "";
3325 const char * EXE_PATH_VALUE   = "";
3326 EOF
3327             fi
3328
3329             if test "$fast_install" = yes; then
3330               cat <<EOF
3331 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
3332 EOF
3333             else
3334               cat <<EOF
3335 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
3336 EOF
3337             fi
3338
3339
3340             cat <<"EOF"
3341
3342 #define LTWRAPPER_OPTION_PREFIX         "--lt-"
3343 #define LTWRAPPER_OPTION_PREFIX_LENGTH  5
3344
3345 static const size_t opt_prefix_len         = LTWRAPPER_OPTION_PREFIX_LENGTH;
3346 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3347
3348 static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
3349
3350 static const size_t env_set_opt_len     = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;
3351 static const char *env_set_opt          = LTWRAPPER_OPTION_PREFIX "env-set";
3352   /* argument is putenv-style "foo=bar", value of foo is set to bar */
3353
3354 static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;
3355 static const char *env_prepend_opt      = LTWRAPPER_OPTION_PREFIX "env-prepend";
3356   /* argument is putenv-style "foo=bar", new value of foo is bar${foo} */
3357
3358 static const size_t env_append_opt_len  = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;
3359 static const char *env_append_opt       = LTWRAPPER_OPTION_PREFIX "env-append";
3360   /* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */
3361
3362 #undef main
3363 int
3364 main (int argc, char *argv[])
3365 {
3366   char **newargz;
3367   int  newargc;
3368   char *tmp_pathspec;
3369   char *actual_cwrapper_path;
3370   char *actual_cwrapper_name;
3371   char *target_name;
3372   char *lt_argv_zero;
3373   intptr_t rval = 127;
3374
3375   int i;
3376
3377   program_name = (char *) xstrdup (base_name (argv[0]));
3378   LTWRAPPER_DEBUGPRINTF (("(main) argv[0]      : %s\n", argv[0]));
3379   LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
3380
3381   /* very simple arg parsing; don't want to rely on getopt */
3382   for (i = 1; i < argc; i++)
3383     {
3384       if (strcmp (argv[i], dumpscript_opt) == 0)
3385         {
3386 EOF
3387             case "$host" in
3388               *mingw* | *cygwin* )
3389                 # make stdout use "unix" line endings
3390                 echo "          setmode(1,_O_BINARY);"
3391                 ;;
3392               esac
3393
3394             cat <<"EOF"
3395           printf ("%s", script_text_part1);
3396           printf ("%s", script_text_part2);
3397           return 0;
3398         }
3399     }
3400
3401   newargz = XMALLOC (char *, argc + 1);
3402   tmp_pathspec = find_executable (argv[0]);
3403   if (tmp_pathspec == NULL)
3404     lt_fatal ("Couldn't find %s", argv[0]);
3405   LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3406                           tmp_pathspec));
3407
3408   actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3409   LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3410                           actual_cwrapper_path));
3411   XFREE (tmp_pathspec);
3412
3413   actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
3414   strendzap (actual_cwrapper_path, actual_cwrapper_name);
3415
3416   /* wrapper name transforms */
3417   strendzap (actual_cwrapper_name, ".exe");
3418   tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
3419   XFREE (actual_cwrapper_name);
3420   actual_cwrapper_name = tmp_pathspec;
3421   tmp_pathspec = 0;
3422
3423   /* target_name transforms -- use actual target program name; might have lt- prefix */
3424   target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
3425   strendzap (target_name, ".exe");
3426   tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
3427   XFREE (target_name);
3428   target_name = tmp_pathspec;
3429   tmp_pathspec = 0;
3430
3431   LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3432                           target_name));
3433 EOF
3434
3435             cat <<EOF
3436   newargz[0] =
3437     XMALLOC (char, (strlen (actual_cwrapper_path) +
3438                     strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
3439   strcpy (newargz[0], actual_cwrapper_path);
3440   strcat (newargz[0], "$objdir");
3441   strcat (newargz[0], "/");
3442 EOF
3443
3444             cat <<"EOF"
3445   /* stop here, and copy so we don't have to do this twice */
3446   tmp_pathspec = xstrdup (newargz[0]);
3447
3448   /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
3449   strcat (newargz[0], actual_cwrapper_name);
3450
3451   /* DO want the lt- prefix here if it exists, so use target_name */
3452   lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
3453   XFREE (tmp_pathspec);
3454   tmp_pathspec = NULL;
3455 EOF
3456
3457             case $host_os in
3458               mingw*)
3459             cat <<"EOF"
3460   {
3461     char* p;
3462     while ((p = strchr (newargz[0], '\\')) != NULL)
3463       {
3464         *p = '/';
3465       }
3466     while ((p = strchr (lt_argv_zero, '\\')) != NULL)
3467       {
3468         *p = '/';
3469       }
3470   }
3471 EOF
3472             ;;
3473             esac
3474
3475             cat <<"EOF"
3476   XFREE (target_name);
3477   XFREE (actual_cwrapper_path);
3478   XFREE (actual_cwrapper_name);
3479
3480   lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3481   lt_setenv ("DUALCASE", "1");  /* for MSK sh */
3482   lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
3483   lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3484
3485   newargc=0;
3486   for (i = 1; i < argc; i++)
3487     {
3488       if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)
3489         {
3490           if (argv[i][env_set_opt_len] == '=')
3491             {
3492               const char *p = argv[i] + env_set_opt_len + 1;
3493               lt_opt_process_env_set (p);
3494             }
3495           else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)
3496             {
3497               lt_opt_process_env_set (argv[++i]); /* don't copy */
3498             }
3499           else
3500             lt_fatal ("%s missing required argument", env_set_opt);
3501           continue;
3502         }
3503       if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)
3504         {
3505           if (argv[i][env_prepend_opt_len] == '=')
3506             {
3507               const char *p = argv[i] + env_prepend_opt_len + 1;
3508               lt_opt_process_env_prepend (p);
3509             }
3510           else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)
3511             {
3512               lt_opt_process_env_prepend (argv[++i]); /* don't copy */
3513             }
3514           else
3515             lt_fatal ("%s missing required argument", env_prepend_opt);
3516           continue;
3517         }
3518       if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)
3519         {
3520           if (argv[i][env_append_opt_len] == '=')
3521             {
3522               const char *p = argv[i] + env_append_opt_len + 1;
3523               lt_opt_process_env_append (p);
3524             }
3525           else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)
3526             {
3527               lt_opt_process_env_append (argv[++i]); /* don't copy */
3528             }
3529           else
3530             lt_fatal ("%s missing required argument", env_append_opt);
3531           continue;
3532         }
3533       if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
3534         {
3535           /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
3536              namespace, but it is not one of the ones we know about and
3537              have already dealt with, above (inluding dump-script), then
3538              report an error. Otherwise, targets might begin to believe
3539              they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
3540              namespace. The first time any user complains about this, we'll
3541              need to make LTWRAPPER_OPTION_PREFIX a configure-time option
3542              or a configure.ac-settable value.
3543            */
3544           lt_fatal ("Unrecognized option in %s namespace: '%s'",
3545                     ltwrapper_option_prefix, argv[i]);
3546         }
3547       /* otherwise ... */
3548       newargz[++newargc] = xstrdup (argv[i]);
3549     }
3550   newargz[++newargc] = NULL;
3551
3552   LTWRAPPER_DEBUGPRINTF     (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
3553   for (i = 0; i < newargc; i++)
3554     {
3555       LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d]   : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
3556     }
3557
3558 EOF
3559
3560             case $host_os in
3561               mingw*)
3562                 cat <<"EOF"
3563   /* execv doesn't actually work on mingw as expected on unix */
3564   rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
3565   if (rval == -1)
3566     {
3567       /* failed to start process */
3568       LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
3569       return 127;
3570     }
3571   return rval;
3572 EOF
3573                 ;;
3574               *)
3575                 cat <<"EOF"
3576   execv (lt_argv_zero, newargz);
3577   return rval; /* =127, but avoids unused variable warning */
3578 EOF
3579                 ;;
3580             esac
3581
3582             cat <<"EOF"
3583 }
3584
3585 void *
3586 xmalloc (size_t num)
3587 {
3588   void *p = (void *) malloc (num);
3589   if (!p)
3590     lt_fatal ("Memory exhausted");
3591
3592   return p;
3593 }
3594
3595 char *
3596 xstrdup (const char *string)
3597 {
3598   return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
3599                           string) : NULL;
3600 }
3601
3602 const char *
3603 base_name (const char *name)
3604 {
3605   const char *base;
3606
3607 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3608   /* Skip over the disk name in MSDOS pathnames. */
3609   if (isalpha ((unsigned char) name[0]) && name[1] == ':')
3610     name += 2;
3611 #endif
3612
3613   for (base = name; *name; name++)
3614     if (IS_DIR_SEPARATOR (*name))
3615       base = name + 1;
3616   return base;
3617 }
3618
3619 int
3620 check_executable (const char *path)
3621 {
3622   struct stat st;
3623
3624   LTWRAPPER_DEBUGPRINTF (("(check_executable)  : %s\n",
3625                           path ? (*path ? path : "EMPTY!") : "NULL!"));
3626   if ((!path) || (!*path))
3627     return 0;
3628
3629   if ((stat (path, &st) >= 0)
3630       && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
3631     return 1;
3632   else
3633     return 0;
3634 }
3635
3636 int
3637 make_executable (const char *path)
3638 {
3639   int rval = 0;
3640   struct stat st;
3641
3642   LTWRAPPER_DEBUGPRINTF (("(make_executable)   : %s\n",
3643                           path ? (*path ? path : "EMPTY!") : "NULL!"));
3644   if ((!path) || (!*path))
3645     return 0;
3646
3647   if (stat (path, &st) >= 0)
3648     {
3649       rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
3650     }
3651   return rval;
3652 }
3653
3654 /* Searches for the full path of the wrapper.  Returns
3655    newly allocated full path name if found, NULL otherwise
3656    Does not chase symlinks, even on platforms that support them.
3657 */
3658 char *
3659 find_executable (const char *wrapper)
3660 {
3661   int has_slash = 0;
3662   const char *p;
3663   const char *p_next;
3664   /* static buffer for getcwd */
3665   char tmp[LT_PATHMAX + 1];
3666   int tmp_len;
3667   char *concat_name;
3668
3669   LTWRAPPER_DEBUGPRINTF (("(find_executable)   : %s\n",
3670                           wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
3671
3672   if ((wrapper == NULL) || (*wrapper == '\0'))
3673     return NULL;
3674
3675   /* Absolute path? */
3676 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3677   if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
3678     {
3679       concat_name = xstrdup (wrapper);
3680       if (check_executable (concat_name))
3681         return concat_name;
3682       XFREE (concat_name);
3683     }
3684   else
3685     {
3686 #endif
3687       if (IS_DIR_SEPARATOR (wrapper[0]))
3688         {
3689           concat_name = xstrdup (wrapper);
3690           if (check_executable (concat_name))
3691             return concat_name;
3692           XFREE (concat_name);
3693         }
3694 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3695     }
3696 #endif
3697
3698   for (p = wrapper; *p; p++)
3699     if (*p == '/')
3700       {
3701         has_slash = 1;
3702         break;
3703       }
3704   if (!has_slash)
3705     {
3706       /* no slashes; search PATH */
3707       const char *path = getenv ("PATH");
3708       if (path != NULL)
3709         {
3710           for (p = path; *p; p = p_next)
3711             {
3712               const char *q;
3713               size_t p_len;
3714               for (q = p; *q; q++)
3715                 if (IS_PATH_SEPARATOR (*q))
3716                   break;
3717               p_len = q - p;
3718               p_next = (*q == '\0' ? q : q + 1);
3719               if (p_len == 0)
3720                 {
3721                   /* empty path: current directory */
3722                   if (getcwd (tmp, LT_PATHMAX) == NULL)
3723                     lt_fatal ("getcwd failed");
3724                   tmp_len = strlen (tmp);
3725                   concat_name =
3726                     XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3727                   memcpy (concat_name, tmp, tmp_len);
3728                   concat_name[tmp_len] = '/';
3729                   strcpy (concat_name + tmp_len + 1, wrapper);
3730                 }
3731               else
3732                 {
3733                   concat_name =
3734                     XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
3735                   memcpy (concat_name, p, p_len);
3736                   concat_name[p_len] = '/';
3737                   strcpy (concat_name + p_len + 1, wrapper);
3738                 }
3739               if (check_executable (concat_name))
3740                 return concat_name;
3741               XFREE (concat_name);
3742             }
3743         }
3744       /* not found in PATH; assume curdir */
3745     }
3746   /* Relative path | not found in path: prepend cwd */
3747   if (getcwd (tmp, LT_PATHMAX) == NULL)
3748     lt_fatal ("getcwd failed");
3749   tmp_len = strlen (tmp);
3750   concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3751   memcpy (concat_name, tmp, tmp_len);
3752   concat_name[tmp_len] = '/';
3753   strcpy (concat_name + tmp_len + 1, wrapper);
3754
3755   if (check_executable (concat_name))
3756     return concat_name;
3757   XFREE (concat_name);
3758   return NULL;
3759 }
3760
3761 char *
3762 chase_symlinks (const char *pathspec)
3763 {
3764 #ifndef S_ISLNK
3765   return xstrdup (pathspec);
3766 #else
3767   char buf[LT_PATHMAX];
3768   struct stat s;
3769   char *tmp_pathspec = xstrdup (pathspec);
3770   char *p;
3771   int has_symlinks = 0;
3772   while (strlen (tmp_pathspec) && !has_symlinks)
3773     {
3774       LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
3775                               tmp_pathspec));
3776       if (lstat (tmp_pathspec, &s) == 0)
3777         {
3778           if (S_ISLNK (s.st_mode) != 0)
3779             {
3780               has_symlinks = 1;
3781               break;
3782             }
3783
3784           /* search backwards for last DIR_SEPARATOR */
3785           p = tmp_pathspec + strlen (tmp_pathspec) - 1;
3786           while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3787             p--;
3788           if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3789             {
3790               /* no more DIR_SEPARATORS left */
3791               break;
3792             }
3793           *p = '\0';
3794         }
3795       else
3796         {
3797           char *errstr = strerror (errno);
3798           lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
3799         }
3800     }
3801   XFREE (tmp_pathspec);
3802
3803   if (!has_symlinks)
3804     {
3805       return xstrdup (pathspec);
3806     }
3807
3808   tmp_pathspec = realpath (pathspec, buf);
3809   if (tmp_pathspec == 0)
3810     {
3811       lt_fatal ("Could not follow symlinks for %s", pathspec);
3812     }
3813   return xstrdup (tmp_pathspec);
3814 #endif
3815 }
3816
3817 char *
3818 strendzap (char *str, const char *pat)
3819 {
3820   size_t len, patlen;
3821
3822   assert (str != NULL);
3823   assert (pat != NULL);
3824
3825   len = strlen (str);
3826   patlen = strlen (pat);
3827
3828   if (patlen <= len)
3829     {
3830       str += len - patlen;
3831       if (strcmp (str, pat) == 0)
3832         *str = '\0';
3833     }
3834   return str;
3835 }
3836
3837 static void
3838 lt_error_core (int exit_status, const char *mode,
3839                const char *message, va_list ap)
3840 {
3841   fprintf (stderr, "%s: %s: ", program_name, mode);
3842   vfprintf (stderr, message, ap);
3843   fprintf (stderr, ".\n");
3844
3845   if (exit_status >= 0)
3846     exit (exit_status);
3847 }
3848
3849 void
3850 lt_fatal (const char *message, ...)
3851 {
3852   va_list ap;
3853   va_start (ap, message);
3854   lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
3855   va_end (ap);
3856 }
3857
3858 void
3859 lt_setenv (const char *name, const char *value)
3860 {
3861   LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
3862                           (name ? name : "<NULL>"),
3863                           (value ? value : "<NULL>")));
3864   {
3865 #ifdef HAVE_SETENV
3866     /* always make a copy, for consistency with !HAVE_SETENV */
3867     char *str = xstrdup (value);
3868     setenv (name, str, 1);
3869 #else
3870     int len = strlen (name) + 1 + strlen (value) + 1;
3871     char *str = XMALLOC (char, len);
3872     sprintf (str, "%s=%s", name, value);
3873     if (putenv (str) != EXIT_SUCCESS)
3874       {
3875         XFREE (str);
3876       }
3877 #endif
3878   }
3879 }
3880
3881 char *
3882 lt_extend_str (const char *orig_value, const char *add, int to_end)
3883 {
3884   char *new_value;
3885   if (orig_value && *orig_value)
3886     {
3887       int orig_value_len = strlen (orig_value);
3888       int add_len = strlen (add);
3889       new_value = XMALLOC (char, add_len + orig_value_len + 1);
3890       if (to_end)
3891         {
3892           strcpy (new_value, orig_value);
3893           strcpy (new_value + orig_value_len, add);
3894         }
3895       else
3896         {
3897           strcpy (new_value, add);
3898           strcpy (new_value + add_len, orig_value);
3899         }
3900     }
3901   else
3902     {
3903       new_value = xstrdup (add);
3904     }
3905   return new_value;
3906 }
3907
3908 int
3909 lt_split_name_value (const char *arg, char** name, char** value)
3910 {
3911   const char *p;
3912   int len;
3913   if (!arg || !*arg)
3914     return 1;
3915
3916   p = strchr (arg, (int)'=');
3917
3918   if (!p)
3919     return 1;
3920
3921   *value = xstrdup (++p);
3922
3923   len = strlen (arg) - strlen (*value);
3924   *name = XMALLOC (char, len);
3925   strncpy (*name, arg, len-1);
3926   (*name)[len - 1] = '\0';
3927
3928   return 0;
3929 }
3930
3931 void
3932 lt_opt_process_env_set (const char *arg)
3933 {
3934   char *name = NULL;
3935   char *value = NULL;
3936
3937   if (lt_split_name_value (arg, &name, &value) != 0)
3938     {
3939       XFREE (name);
3940       XFREE (value);
3941       lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);
3942     }
3943
3944   lt_setenv (name, value);
3945   XFREE (name);
3946   XFREE (value);
3947 }
3948
3949 void
3950 lt_opt_process_env_prepend (const char *arg)
3951 {
3952   char *name = NULL;
3953   char *value = NULL;
3954   char *new_value = NULL;
3955
3956   if (lt_split_name_value (arg, &name, &value) != 0)
3957     {
3958       XFREE (name);
3959       XFREE (value);
3960       lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);
3961     }
3962
3963   new_value = lt_extend_str (getenv (name), value, 0);
3964   lt_setenv (name, new_value);
3965   XFREE (new_value);
3966   XFREE (name);
3967   XFREE (value);
3968 }
3969
3970 void
3971 lt_opt_process_env_append (const char *arg)
3972 {
3973   char *name = NULL;
3974   char *value = NULL;
3975   char *new_value = NULL;
3976
3977   if (lt_split_name_value (arg, &name, &value) != 0)
3978     {
3979       XFREE (name);
3980       XFREE (value);
3981       lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);
3982     }
3983
3984   new_value = lt_extend_str (getenv (name), value, 1);
3985   lt_setenv (name, new_value);
3986   XFREE (new_value);
3987   XFREE (name);
3988   XFREE (value);
3989 }
3990
3991 void
3992 lt_update_exe_path (const char *name, const char *value)
3993 {
3994   LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
3995                           (name ? name : "<NULL>"),
3996                           (value ? value : "<NULL>")));
3997
3998   if (name && *name && value && *value)
3999     {
4000       char *new_value = lt_extend_str (getenv (name), value, 0);
4001       /* some systems can't cope with a ':'-terminated path #' */
4002       int len = strlen (new_value);
4003       while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4004         {
4005           new_value[len-1] = '\0';
4006         }
4007       lt_setenv (name, new_value);
4008       XFREE (new_value);
4009     }
4010 }
4011
4012 void
4013 lt_update_lib_path (const char *name, const char *value)
4014 {
4015   LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4016                           (name ? name : "<NULL>"),
4017                           (value ? value : "<NULL>")));
4018
4019   if (name && *name && value && *value)
4020     {
4021       char *new_value = lt_extend_str (getenv (name), value, 0);
4022       lt_setenv (name, new_value);
4023       XFREE (new_value);
4024     }
4025 }
4026
4027
4028 EOF
4029 }
4030 # end: func_emit_cwrapperexe_src
4031
4032 # func_mode_link arg...
4033 func_mode_link ()
4034 {
4035     $opt_debug
4036     case $host in
4037     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4038       # It is impossible to link a dll without this setting, and
4039       # we shouldn't force the makefile maintainer to figure out
4040       # which system we are compiling for in order to pass an extra
4041       # flag for every libtool invocation.
4042       # allow_undefined=no
4043
4044       # FIXME: Unfortunately, there are problems with the above when trying
4045       # to make a dll which has undefined symbols, in which case not
4046       # even a static library is built.  For now, we need to specify
4047       # -no-undefined on the libtool link line when we can be certain
4048       # that all symbols are satisfied, otherwise we get a static library.
4049       allow_undefined=yes
4050       ;;
4051     *)
4052       allow_undefined=yes
4053       ;;
4054     esac
4055     libtool_args=$nonopt
4056     base_compile="$nonopt $@"
4057     compile_command=$nonopt
4058     finalize_command=$nonopt
4059
4060     compile_rpath=
4061     finalize_rpath=
4062     compile_shlibpath=
4063     finalize_shlibpath=
4064     convenience=
4065     old_convenience=
4066     deplibs=
4067     old_deplibs=
4068     compiler_flags=
4069     linker_flags=
4070     dllsearchpath=
4071     lib_search_path=`pwd`
4072     inst_prefix_dir=
4073     new_inherited_linker_flags=
4074
4075     avoid_version=no
4076     dlfiles=
4077     dlprefiles=
4078     dlself=no
4079     export_dynamic=no
4080     export_symbols=
4081     export_symbols_regex=
4082     generated=
4083     libobjs=
4084     ltlibs=
4085     module=no
4086     no_install=no
4087     objs=
4088     non_pic_objects=
4089     precious_files_regex=
4090     prefer_static_libs=no
4091     preload=no
4092     prev=
4093     prevarg=
4094     release=
4095     rpath=
4096     xrpath=
4097     perm_rpath=
4098     temp_rpath=
4099     thread_safe=no
4100     vinfo=
4101     vinfo_number=no
4102     weak_libs=
4103     single_module="${wl}-single_module"
4104     func_infer_tag $base_compile
4105
4106     # We need to know -static, to get the right output filenames.
4107     for arg
4108     do
4109       case $arg in
4110       -shared)
4111         test "$build_libtool_libs" != yes && \
4112           func_fatal_configuration "can not build a shared library"
4113         build_old_libs=no
4114         break
4115         ;;
4116       -all-static | -static | -static-libtool-libs)
4117         case $arg in
4118         -all-static)
4119           if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
4120             func_warning "complete static linking is impossible in this configuration"
4121           fi
4122           if test -n "$link_static_flag"; then
4123             dlopen_self=$dlopen_self_static
4124           fi
4125           prefer_static_libs=yes
4126           ;;
4127         -static)
4128           if test -z "$pic_flag" && test -n "$link_static_flag"; then
4129             dlopen_self=$dlopen_self_static
4130           fi
4131           prefer_static_libs=built
4132           ;;
4133         -static-libtool-libs)
4134           if test -z "$pic_flag" && test -n "$link_static_flag"; then
4135             dlopen_self=$dlopen_self_static
4136           fi
4137           prefer_static_libs=yes
4138           ;;
4139         esac
4140         build_libtool_libs=no
4141         build_old_libs=yes
4142         break
4143         ;;
4144       esac
4145     done
4146
4147     # See if our shared archives depend on static archives.
4148     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
4149
4150     # Go through the arguments, transforming them on the way.
4151     while test "$#" -gt 0; do
4152       arg="$1"
4153       shift
4154       func_quote_for_eval "$arg"
4155       qarg=$func_quote_for_eval_unquoted_result
4156       func_append libtool_args " $func_quote_for_eval_result"
4157
4158       # If the previous option needs an argument, assign it.
4159       if test -n "$prev"; then
4160         case $prev in
4161         output)
4162           func_append compile_command " @OUTPUT@"
4163           func_append finalize_command " @OUTPUT@"
4164           ;;
4165         esac
4166
4167         case $prev in
4168         dlfiles|dlprefiles)
4169           if test "$preload" = no; then
4170             # Add the symbol object into the linking commands.
4171             func_append compile_command " @SYMFILE@"
4172             func_append finalize_command " @SYMFILE@"
4173             preload=yes
4174           fi
4175           case $arg in
4176           *.la | *.lo) ;;  # We handle these cases below.
4177           force)
4178             if test "$dlself" = no; then
4179               dlself=needless
4180               export_dynamic=yes
4181             fi
4182             prev=
4183             continue
4184             ;;
4185           self)
4186             if test "$prev" = dlprefiles; then
4187               dlself=yes
4188             elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
4189               dlself=yes
4190             else
4191               dlself=needless
4192               export_dynamic=yes
4193             fi
4194             prev=
4195             continue
4196             ;;
4197           *)
4198             if test "$prev" = dlfiles; then
4199               dlfiles="$dlfiles $arg"
4200             else
4201               dlprefiles="$dlprefiles $arg"
4202             fi
4203             prev=
4204             continue
4205             ;;
4206           esac
4207           ;;
4208         expsyms)
4209           export_symbols="$arg"
4210           test -f "$arg" \
4211             || func_fatal_error "symbol file \`$arg' does not exist"
4212           prev=
4213           continue
4214           ;;
4215         expsyms_regex)
4216           export_symbols_regex="$arg"
4217           prev=
4218           continue
4219           ;;
4220         framework)
4221           case $host in
4222             *-*-darwin*)
4223               case "$deplibs " in
4224                 *" $qarg.ltframework "*) ;;
4225                 *) deplibs="$deplibs $qarg.ltframework" # this is fixed later
4226                    ;;
4227               esac
4228               ;;
4229           esac
4230           prev=
4231           continue
4232           ;;
4233         inst_prefix)
4234           inst_prefix_dir="$arg"
4235           prev=
4236           continue
4237           ;;
4238         objectlist)
4239           if test -f "$arg"; then
4240             save_arg=$arg
4241             moreargs=
4242             for fil in `cat "$save_arg"`
4243             do
4244 #             moreargs="$moreargs $fil"
4245               arg=$fil
4246               # A libtool-controlled object.
4247
4248               # Check to see that this really is a libtool object.
4249               if func_lalib_unsafe_p "$arg"; then
4250                 pic_object=
4251                 non_pic_object=
4252
4253                 # Read the .lo file
4254                 func_source "$arg"
4255
4256                 if test -z "$pic_object" ||
4257                    test -z "$non_pic_object" ||
4258                    test "$pic_object" = none &&
4259                    test "$non_pic_object" = none; then
4260                   func_fatal_error "cannot find name of object for \`$arg'"
4261                 fi
4262
4263                 # Extract subdirectory from the argument.
4264                 func_dirname "$arg" "/" ""
4265                 xdir="$func_dirname_result"
4266
4267                 if test "$pic_object" != none; then
4268                   # Prepend the subdirectory the object is found in.
4269                   pic_object="$xdir$pic_object"
4270
4271                   if test "$prev" = dlfiles; then
4272                     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4273                       dlfiles="$dlfiles $pic_object"
4274                       prev=
4275                       continue
4276                     else
4277                       # If libtool objects are unsupported, then we need to preload.
4278                       prev=dlprefiles
4279                     fi
4280                   fi
4281
4282                   # CHECK ME:  I think I busted this.  -Ossama
4283                   if test "$prev" = dlprefiles; then
4284                     # Preload the old-style object.
4285                     dlprefiles="$dlprefiles $pic_object"
4286                     prev=
4287                   fi
4288
4289                   # A PIC object.
4290                   func_append libobjs " $pic_object"
4291                   arg="$pic_object"
4292                 fi
4293
4294                 # Non-PIC object.
4295                 if test "$non_pic_object" != none; then
4296                   # Prepend the subdirectory the object is found in.
4297                   non_pic_object="$xdir$non_pic_object"
4298
4299                   # A standard non-PIC object
4300                   func_append non_pic_objects " $non_pic_object"
4301                   if test -z "$pic_object" || test "$pic_object" = none ; then
4302                     arg="$non_pic_object"
4303                   fi
4304                 else
4305                   # If the PIC object exists, use it instead.
4306                   # $xdir was prepended to $pic_object above.
4307                   non_pic_object="$pic_object"
4308                   func_append non_pic_objects " $non_pic_object"
4309                 fi
4310               else
4311                 # Only an error if not doing a dry-run.
4312                 if $opt_dry_run; then
4313                   # Extract subdirectory from the argument.
4314                   func_dirname "$arg" "/" ""
4315                   xdir="$func_dirname_result"
4316
4317                   func_lo2o "$arg"
4318                   pic_object=$xdir$objdir/$func_lo2o_result
4319                   non_pic_object=$xdir$func_lo2o_result
4320                   func_append libobjs " $pic_object"
4321                   func_append non_pic_objects " $non_pic_object"
4322                 else
4323                   func_fatal_error "\`$arg' is not a valid libtool object"
4324                 fi
4325               fi
4326             done
4327           else
4328             func_fatal_error "link input file \`$arg' does not exist"
4329           fi
4330           arg=$save_arg
4331           prev=
4332           continue
4333           ;;
4334         precious_regex)
4335           precious_files_regex="$arg"
4336           prev=
4337           continue
4338           ;;
4339         release)
4340           release="-$arg"
4341           prev=
4342           continue
4343           ;;
4344         rpath | xrpath)
4345           # We need an absolute path.
4346           case $arg in
4347           [\\/]* | [A-Za-z]:[\\/]*) ;;
4348           *)
4349             func_fatal_error "only absolute run-paths are allowed"
4350             ;;
4351           esac
4352           if test "$prev" = rpath; then
4353             case "$rpath " in
4354             *" $arg "*) ;;
4355             *) rpath="$rpath $arg" ;;
4356             esac
4357           else
4358             case "$xrpath " in
4359             *" $arg "*) ;;
4360             *) xrpath="$xrpath $arg" ;;
4361             esac
4362           fi
4363           prev=
4364           continue
4365           ;;
4366         shrext)
4367           shrext_cmds="$arg"
4368           prev=
4369           continue
4370           ;;
4371         weak)
4372           weak_libs="$weak_libs $arg"
4373           prev=
4374           continue
4375           ;;
4376         xcclinker)
4377           linker_flags="$linker_flags $qarg"
4378           compiler_flags="$compiler_flags $qarg"
4379           prev=
4380           func_append compile_command " $qarg"
4381           func_append finalize_command " $qarg"
4382           continue
4383           ;;
4384         xcompiler)
4385           compiler_flags="$compiler_flags $qarg"
4386           prev=
4387           func_append compile_command " $qarg"
4388           func_append finalize_command " $qarg"
4389           continue
4390           ;;
4391         xlinker)
4392           linker_flags="$linker_flags $qarg"
4393           compiler_flags="$compiler_flags $wl$qarg"
4394           prev=
4395           func_append compile_command " $wl$qarg"
4396           func_append finalize_command " $wl$qarg"
4397           continue
4398           ;;
4399         *)
4400           eval "$prev=\"\$arg\""
4401           prev=
4402           continue
4403           ;;
4404         esac
4405       fi # test -n "$prev"
4406
4407       prevarg="$arg"
4408
4409       case $arg in
4410       -all-static)
4411         if test -n "$link_static_flag"; then
4412           # See comment for -static flag below, for more details.
4413           func_append compile_command " $link_static_flag"
4414           func_append finalize_command " $link_static_flag"
4415         fi
4416         continue
4417         ;;
4418
4419       -allow-undefined)
4420         # FIXME: remove this flag sometime in the future.
4421         func_fatal_error "\`-allow-undefined' must not be used because it is the default"
4422         ;;
4423
4424       -avoid-version)
4425         avoid_version=yes
4426         continue
4427         ;;
4428
4429       -dlopen)
4430         prev=dlfiles
4431         continue
4432         ;;
4433
4434       -dlpreopen)
4435         prev=dlprefiles
4436         continue
4437         ;;
4438
4439       -export-dynamic)
4440         export_dynamic=yes
4441         continue
4442         ;;
4443
4444       -export-symbols | -export-symbols-regex)
4445         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
4446           func_fatal_error "more than one -exported-symbols argument is not allowed"
4447         fi
4448         if test "X$arg" = "X-export-symbols"; then
4449           prev=expsyms
4450         else
4451           prev=expsyms_regex
4452         fi
4453         continue
4454         ;;
4455
4456       -framework)
4457         prev=framework
4458         continue
4459         ;;
4460
4461       -inst-prefix-dir)
4462         prev=inst_prefix
4463         continue
4464         ;;
4465
4466       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
4467       # so, if we see these flags be careful not to treat them like -L
4468       -L[A-Z][A-Z]*:*)
4469         case $with_gcc/$host in
4470         no/*-*-irix* | /*-*-irix*)
4471           func_append compile_command " $arg"
4472           func_append finalize_command " $arg"
4473           ;;
4474         esac
4475         continue
4476         ;;
4477
4478       -L*)
4479         func_stripname '-L' '' "$arg"
4480         dir=$func_stripname_result
4481         if test -z "$dir"; then
4482           if test "$#" -gt 0; then
4483             func_fatal_error "require no space between \`-L' and \`$1'"
4484           else
4485             func_fatal_error "need path for \`-L' option"
4486           fi
4487         fi
4488         # We need an absolute path.
4489         case $dir in
4490         [\\/]* | [A-Za-z]:[\\/]*) ;;
4491         *)
4492           absdir=`cd "$dir" && pwd`
4493           test -z "$absdir" && \
4494             func_fatal_error "cannot determine absolute directory name of \`$dir'"
4495           dir="$absdir"
4496           ;;
4497         esac
4498         case "$deplibs " in
4499         *" -L$dir "*) ;;
4500         *)
4501           deplibs="$deplibs -L$dir"
4502           lib_search_path="$lib_search_path $dir"
4503           ;;
4504         esac
4505         case $host in
4506         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4507           testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
4508           case :$dllsearchpath: in
4509           *":$dir:"*) ;;
4510           ::) dllsearchpath=$dir;;
4511           *) dllsearchpath="$dllsearchpath:$dir";;
4512           esac
4513           case :$dllsearchpath: in
4514           *":$testbindir:"*) ;;
4515           ::) dllsearchpath=$testbindir;;
4516           *) dllsearchpath="$dllsearchpath:$testbindir";;
4517           esac
4518           ;;
4519         esac
4520         continue
4521         ;;
4522
4523       -l*)
4524         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
4525           case $host in
4526           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
4527             # These systems don't actually have a C or math library (as such)
4528             continue
4529             ;;
4530           *-*-os2*)
4531             # These systems don't actually have a C library (as such)
4532             test "X$arg" = "X-lc" && continue
4533             ;;
4534           *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4535             # Do not include libc due to us having libc/libc_r.
4536             test "X$arg" = "X-lc" && continue
4537             ;;
4538           *-*-rhapsody* | *-*-darwin1.[012])
4539             # Rhapsody C and math libraries are in the System framework
4540             deplibs="$deplibs System.ltframework"
4541             continue
4542             ;;
4543           *-*-sco3.2v5* | *-*-sco5v6*)
4544             # Causes problems with __ctype
4545             test "X$arg" = "X-lc" && continue
4546             ;;
4547           *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
4548             # Compiler inserts libc in the correct place for threads to work
4549             test "X$arg" = "X-lc" && continue
4550             ;;
4551           esac
4552         elif test "X$arg" = "X-lc_r"; then
4553          case $host in
4554          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4555            # Do not include libc_r directly, use -pthread flag.
4556            continue
4557            ;;
4558          esac
4559         fi
4560         deplibs="$deplibs $arg"
4561         continue
4562         ;;
4563
4564       -module)
4565         module=yes
4566         continue
4567         ;;
4568
4569       # Tru64 UNIX uses -model [arg] to determine the layout of C++
4570       # classes, name mangling, and exception handling.
4571       # Darwin uses the -arch flag to determine output architecture.
4572       -model|-arch|-isysroot)
4573         compiler_flags="$compiler_flags $arg"
4574         func_append compile_command " $arg"
4575         func_append finalize_command " $arg"
4576         prev=xcompiler
4577         continue
4578         ;;
4579
4580       -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4581         compiler_flags="$compiler_flags $arg"
4582         func_append compile_command " $arg"
4583         func_append finalize_command " $arg"
4584         case "$new_inherited_linker_flags " in
4585             *" $arg "*) ;;
4586             * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
4587         esac
4588         continue
4589         ;;
4590
4591       -multi_module)
4592         single_module="${wl}-multi_module"
4593         continue
4594         ;;
4595
4596       -no-fast-install)
4597         fast_install=no
4598         continue
4599         ;;
4600
4601       -no-install)
4602         case $host in
4603         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
4604           # The PATH hackery in wrapper scripts is required on Windows
4605           # and Darwin in order for the loader to find any dlls it needs.
4606           func_warning "\`-no-install' is ignored for $host"
4607           func_warning "assuming \`-no-fast-install' instead"
4608           fast_install=no
4609           ;;
4610         *) no_install=yes ;;
4611         esac
4612         continue
4613         ;;
4614
4615       -no-undefined)
4616         allow_undefined=no
4617         continue
4618         ;;
4619
4620       -objectlist)
4621         prev=objectlist
4622         continue
4623         ;;
4624
4625       -o) prev=output ;;
4626
4627       -precious-files-regex)
4628         prev=precious_regex
4629         continue
4630         ;;
4631
4632       -release)
4633         prev=release
4634         continue
4635         ;;
4636
4637       -rpath)
4638         prev=rpath
4639         continue
4640         ;;
4641
4642       -R)
4643         prev=xrpath
4644         continue
4645         ;;
4646
4647       -R*)
4648         func_stripname '-R' '' "$arg"
4649         dir=$func_stripname_result
4650         # We need an absolute path.
4651         case $dir in
4652         [\\/]* | [A-Za-z]:[\\/]*) ;;
4653         *)
4654           func_fatal_error "only absolute run-paths are allowed"
4655           ;;
4656         esac
4657         case "$xrpath " in
4658         *" $dir "*) ;;
4659         *) xrpath="$xrpath $dir" ;;
4660         esac
4661         continue
4662         ;;
4663
4664       -shared)
4665         # The effects of -shared are defined in a previous loop.
4666         continue
4667         ;;
4668
4669       -shrext)
4670         prev=shrext
4671         continue
4672         ;;
4673
4674       -static | -static-libtool-libs)
4675         # The effects of -static are defined in a previous loop.
4676         # We used to do the same as -all-static on platforms that
4677         # didn't have a PIC flag, but the assumption that the effects
4678         # would be equivalent was wrong.  It would break on at least
4679         # Digital Unix and AIX.
4680         continue
4681         ;;
4682
4683       -thread-safe)
4684         thread_safe=yes
4685         continue
4686         ;;
4687
4688       -version-info)
4689         prev=vinfo
4690         continue
4691         ;;
4692
4693       -version-number)
4694         prev=vinfo
4695         vinfo_number=yes
4696         continue
4697         ;;
4698
4699       -weak)
4700         prev=weak
4701         continue
4702         ;;
4703
4704       -Wc,*)
4705         func_stripname '-Wc,' '' "$arg"
4706         args=$func_stripname_result
4707         arg=
4708         save_ifs="$IFS"; IFS=','
4709         for flag in $args; do
4710           IFS="$save_ifs"
4711           func_quote_for_eval "$flag"
4712           arg="$arg $wl$func_quote_for_eval_result"
4713           compiler_flags="$compiler_flags $func_quote_for_eval_result"
4714         done
4715         IFS="$save_ifs"
4716         func_stripname ' ' '' "$arg"
4717         arg=$func_stripname_result
4718         ;;
4719
4720       -Wl,*)
4721         func_stripname '-Wl,' '' "$arg"
4722         args=$func_stripname_result
4723         arg=
4724         save_ifs="$IFS"; IFS=','
4725         for flag in $args; do
4726           IFS="$save_ifs"
4727           func_quote_for_eval "$flag"
4728           arg="$arg $wl$func_quote_for_eval_result"
4729           compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
4730           linker_flags="$linker_flags $func_quote_for_eval_result"
4731         done
4732         IFS="$save_ifs"
4733         func_stripname ' ' '' "$arg"
4734         arg=$func_stripname_result
4735         ;;
4736
4737       -Xcompiler)
4738         prev=xcompiler
4739         continue
4740         ;;
4741
4742       -Xlinker)
4743         prev=xlinker
4744         continue
4745         ;;
4746
4747       -XCClinker)
4748         prev=xcclinker
4749         continue
4750         ;;
4751
4752       # -msg_* for osf cc
4753       -msg_*)
4754         func_quote_for_eval "$arg"
4755         arg="$func_quote_for_eval_result"
4756         ;;
4757
4758       # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
4759       # -r[0-9][0-9]* specifies the processor on the SGI compiler
4760       # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
4761       # +DA*, +DD* enable 64-bit mode on the HP compiler
4762       # -q* pass through compiler args for the IBM compiler
4763       # -m*, -t[45]*, -txscale* pass through architecture-specific
4764       # compiler args for GCC
4765       # -F/path gives path to uninstalled frameworks, gcc on darwin
4766       # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
4767       # @file GCC response files
4768       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
4769       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
4770         func_quote_for_eval "$arg"
4771         arg="$func_quote_for_eval_result"
4772         func_append compile_command " $arg"
4773         func_append finalize_command " $arg"
4774         compiler_flags="$compiler_flags $arg"
4775         continue
4776         ;;
4777
4778       # Some other compiler flag.
4779       -* | +*)
4780         func_quote_for_eval "$arg"
4781         arg="$func_quote_for_eval_result"
4782         ;;
4783
4784       *.$objext)
4785         # A standard object.
4786         objs="$objs $arg"
4787         ;;
4788
4789       *.lo)
4790         # A libtool-controlled object.
4791
4792         # Check to see that this really is a libtool object.
4793         if func_lalib_unsafe_p "$arg"; then
4794           pic_object=
4795           non_pic_object=
4796
4797           # Read the .lo file
4798           func_source "$arg"
4799
4800           if test -z "$pic_object" ||
4801              test -z "$non_pic_object" ||
4802              test "$pic_object" = none &&
4803              test "$non_pic_object" = none; then
4804             func_fatal_error "cannot find name of object for \`$arg'"
4805           fi
4806
4807           # Extract subdirectory from the argument.
4808           func_dirname "$arg" "/" ""
4809           xdir="$func_dirname_result"
4810
4811           if test "$pic_object" != none; then
4812             # Prepend the subdirectory the object is found in.
4813             pic_object="$xdir$pic_object"
4814
4815             if test "$prev" = dlfiles; then
4816               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4817                 dlfiles="$dlfiles $pic_object"
4818                 prev=
4819                 continue
4820               else
4821                 # If libtool objects are unsupported, then we need to preload.
4822                 prev=dlprefiles
4823               fi
4824             fi
4825
4826             # CHECK ME:  I think I busted this.  -Ossama
4827             if test "$prev" = dlprefiles; then
4828               # Preload the old-style object.
4829               dlprefiles="$dlprefiles $pic_object"
4830               prev=
4831             fi
4832
4833             # A PIC object.
4834             func_append libobjs " $pic_object"
4835             arg="$pic_object"
4836           fi
4837
4838           # Non-PIC object.
4839           if test "$non_pic_object" != none; then
4840             # Prepend the subdirectory the object is found in.
4841             non_pic_object="$xdir$non_pic_object"
4842
4843             # A standard non-PIC object
4844             func_append non_pic_objects " $non_pic_object"
4845             if test -z "$pic_object" || test "$pic_object" = none ; then
4846               arg="$non_pic_object"
4847             fi
4848           else
4849             # If the PIC object exists, use it instead.
4850             # $xdir was prepended to $pic_object above.
4851             non_pic_object="$pic_object"
4852             func_append non_pic_objects " $non_pic_object"
4853           fi
4854         else
4855           # Only an error if not doing a dry-run.
4856           if $opt_dry_run; then
4857             # Extract subdirectory from the argument.
4858             func_dirname "$arg" "/" ""
4859             xdir="$func_dirname_result"
4860
4861             func_lo2o "$arg"
4862             pic_object=$xdir$objdir/$func_lo2o_result
4863             non_pic_object=$xdir$func_lo2o_result
4864             func_append libobjs " $pic_object"
4865             func_append non_pic_objects " $non_pic_object"
4866           else
4867             func_fatal_error "\`$arg' is not a valid libtool object"
4868           fi
4869         fi
4870         ;;
4871
4872       *.$libext)
4873         # An archive.
4874         deplibs="$deplibs $arg"
4875         old_deplibs="$old_deplibs $arg"
4876         continue
4877         ;;
4878
4879       *.la)
4880         # A libtool-controlled library.
4881
4882         if test "$prev" = dlfiles; then
4883           # This library was specified with -dlopen.
4884           dlfiles="$dlfiles $arg"
4885           prev=
4886         elif test "$prev" = dlprefiles; then
4887           # The library was specified with -dlpreopen.
4888           dlprefiles="$dlprefiles $arg"
4889           prev=
4890         else
4891           deplibs="$deplibs $arg"
4892         fi
4893         continue
4894         ;;
4895
4896       # Some other compiler argument.
4897       *)
4898         # Unknown arguments in both finalize_command and compile_command need
4899         # to be aesthetically quoted because they are evaled later.
4900         func_quote_for_eval "$arg"
4901         arg="$func_quote_for_eval_result"
4902         ;;
4903       esac # arg
4904
4905       # Now actually substitute the argument into the commands.
4906       if test -n "$arg"; then
4907         func_append compile_command " $arg"
4908         func_append finalize_command " $arg"
4909       fi
4910     done # argument parsing loop
4911
4912     test -n "$prev" && \
4913       func_fatal_help "the \`$prevarg' option requires an argument"
4914
4915     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
4916       eval arg=\"$export_dynamic_flag_spec\"
4917       func_append compile_command " $arg"
4918       func_append finalize_command " $arg"
4919     fi
4920
4921     oldlibs=
4922     # calculate the name of the file, without its directory
4923     func_basename "$output"
4924     outputname="$func_basename_result"
4925     libobjs_save="$libobjs"
4926
4927     if test -n "$shlibpath_var"; then
4928       # get the directories listed in $shlibpath_var
4929       eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
4930     else
4931       shlib_search_path=
4932     fi
4933     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
4934     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
4935
4936     func_dirname "$output" "/" ""
4937     output_objdir="$func_dirname_result$objdir"
4938     # Create the object directory.
4939     func_mkdir_p "$output_objdir"
4940
4941     # Determine the type of output
4942     case $output in
4943     "")
4944       func_fatal_help "you must specify an output file"
4945       ;;
4946     *.$libext) linkmode=oldlib ;;
4947     *.lo | *.$objext) linkmode=obj ;;
4948     *.la) linkmode=lib ;;
4949     *) linkmode=prog ;; # Anything else should be a program.
4950     esac
4951
4952     specialdeplibs=
4953
4954     libs=
4955     # Find all interdependent deplibs by searching for libraries
4956     # that are linked more than once (e.g. -la -lb -la)
4957     for deplib in $deplibs; do
4958       if $opt_duplicate_deps ; then
4959         case "$libs " in
4960         *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
4961         esac
4962       fi
4963       libs="$libs $deplib"
4964     done
4965
4966     if test "$linkmode" = lib; then
4967       libs="$predeps $libs $compiler_lib_search_path $postdeps"
4968
4969       # Compute libraries that are listed more than once in $predeps
4970       # $postdeps and mark them as special (i.e., whose duplicates are
4971       # not to be eliminated).
4972       pre_post_deps=
4973       if $opt_duplicate_compiler_generated_deps; then
4974         for pre_post_dep in $predeps $postdeps; do
4975           case "$pre_post_deps " in
4976           *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
4977           esac
4978           pre_post_deps="$pre_post_deps $pre_post_dep"
4979         done
4980       fi
4981       pre_post_deps=
4982     fi
4983
4984     deplibs=
4985     newdependency_libs=
4986     newlib_search_path=
4987     need_relink=no # whether we're linking any uninstalled libtool libraries
4988     notinst_deplibs= # not-installed libtool libraries
4989     notinst_path= # paths that contain not-installed libtool libraries
4990
4991     case $linkmode in
4992     lib)
4993         passes="conv dlpreopen link"
4994         for file in $dlfiles $dlprefiles; do
4995           case $file in
4996           *.la) ;;
4997           *)
4998             func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
4999             ;;
5000           esac
5001         done
5002         ;;
5003     prog)
5004         compile_deplibs=
5005         finalize_deplibs=
5006         alldeplibs=no
5007         newdlfiles=
5008         newdlprefiles=
5009         passes="conv scan dlopen dlpreopen link"
5010         ;;
5011     *)  passes="conv"
5012         ;;
5013     esac
5014
5015     for pass in $passes; do
5016       # The preopen pass in lib mode reverses $deplibs; put it back here
5017       # so that -L comes before libs that need it for instance...
5018       if test "$linkmode,$pass" = "lib,link"; then
5019         ## FIXME: Find the place where the list is rebuilt in the wrong
5020         ##        order, and fix it there properly
5021         tmp_deplibs=
5022         for deplib in $deplibs; do
5023           tmp_deplibs="$deplib $tmp_deplibs"
5024         done
5025         deplibs="$tmp_deplibs"
5026       fi
5027
5028       if test "$linkmode,$pass" = "lib,link" ||
5029          test "$linkmode,$pass" = "prog,scan"; then
5030         libs="$deplibs"
5031         deplibs=
5032       fi
5033       if test "$linkmode" = prog; then
5034         case $pass in
5035         dlopen) libs="$dlfiles" ;;
5036         dlpreopen) libs="$dlprefiles" ;;
5037         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
5038         esac
5039       fi
5040       if test "$linkmode,$pass" = "lib,dlpreopen"; then
5041         # Collect and forward deplibs of preopened libtool libs
5042         for lib in $dlprefiles; do
5043           # Ignore non-libtool-libs
5044           dependency_libs=
5045           case $lib in
5046           *.la) func_source "$lib" ;;
5047           esac
5048
5049           # Collect preopened libtool deplibs, except any this library
5050           # has declared as weak libs
5051           for deplib in $dependency_libs; do
5052             deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
5053             case " $weak_libs " in
5054             *" $deplib_base "*) ;;
5055             *) deplibs="$deplibs $deplib" ;;
5056             esac
5057           done
5058         done
5059         libs="$dlprefiles"
5060       fi
5061       if test "$pass" = dlopen; then
5062         # Collect dlpreopened libraries
5063         save_deplibs="$deplibs"
5064         deplibs=
5065       fi
5066
5067       for deplib in $libs; do
5068         lib=
5069         found=no
5070         case $deplib in
5071         -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5072           if test "$linkmode,$pass" = "prog,link"; then
5073             compile_deplibs="$deplib $compile_deplibs"
5074             finalize_deplibs="$deplib $finalize_deplibs"
5075           else
5076             compiler_flags="$compiler_flags $deplib"
5077             if test "$linkmode" = lib ; then
5078                 case "$new_inherited_linker_flags " in
5079                     *" $deplib "*) ;;
5080                     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5081                 esac
5082             fi
5083           fi
5084           continue
5085           ;;
5086         -l*)
5087           if test "$linkmode" != lib && test "$linkmode" != prog; then
5088             func_warning "\`-l' is ignored for archives/objects"
5089             continue
5090           fi
5091           func_stripname '-l' '' "$deplib"
5092           name=$func_stripname_result
5093           if test "$linkmode" = lib; then
5094             searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
5095           else
5096             searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
5097           fi
5098           for searchdir in $searchdirs; do
5099             for search_ext in .la $std_shrext .so .a; do
5100               # Search the libtool library
5101               lib="$searchdir/lib${name}${search_ext}"
5102               if test -f "$lib"; then
5103                 if test "$search_ext" = ".la"; then
5104                   found=yes
5105                 else
5106                   found=no
5107                 fi
5108                 break 2
5109               fi
5110             done
5111           done
5112           if test "$found" != yes; then
5113             # deplib doesn't seem to be a libtool library
5114             if test "$linkmode,$pass" = "prog,link"; then
5115               compile_deplibs="$deplib $compile_deplibs"
5116               finalize_deplibs="$deplib $finalize_deplibs"
5117             else
5118               deplibs="$deplib $deplibs"
5119               test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5120             fi
5121             continue
5122           else # deplib is a libtool library
5123             # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
5124             # We need to do some special things here, and not later.
5125             if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
5126               case " $predeps $postdeps " in
5127               *" $deplib "*)
5128                 if func_lalib_p "$lib"; then
5129                   library_names=
5130                   old_library=
5131                   func_source "$lib"
5132                   for l in $old_library $library_names; do
5133                     ll="$l"
5134                   done
5135                   if test "X$ll" = "X$old_library" ; then # only static version available
5136                     found=no
5137                     func_dirname "$lib" "" "."
5138                     ladir="$func_dirname_result"
5139                     lib=$ladir/$old_library
5140                     if test "$linkmode,$pass" = "prog,link"; then
5141                       compile_deplibs="$deplib $compile_deplibs"
5142                       finalize_deplibs="$deplib $finalize_deplibs"
5143                     else
5144                       deplibs="$deplib $deplibs"
5145                       test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5146                     fi
5147                     continue
5148                   fi
5149                 fi
5150                 ;;
5151               *) ;;
5152               esac
5153             fi
5154           fi
5155           ;; # -l
5156         *.ltframework)
5157           if test "$linkmode,$pass" = "prog,link"; then
5158             compile_deplibs="$deplib $compile_deplibs"
5159             finalize_deplibs="$deplib $finalize_deplibs"
5160           else
5161             deplibs="$deplib $deplibs"
5162             if test "$linkmode" = lib ; then
5163                 case "$new_inherited_linker_flags " in
5164                     *" $deplib "*) ;;
5165                     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5166                 esac
5167             fi
5168           fi
5169           continue
5170           ;;
5171         -L*)
5172           case $linkmode in
5173           lib)
5174             deplibs="$deplib $deplibs"
5175             test "$pass" = conv && continue
5176             newdependency_libs="$deplib $newdependency_libs"
5177             func_stripname '-L' '' "$deplib"
5178             newlib_search_path="$newlib_search_path $func_stripname_result"
5179             ;;
5180           prog)
5181             if test "$pass" = conv; then
5182               deplibs="$deplib $deplibs"
5183               continue
5184             fi
5185             if test "$pass" = scan; then
5186               deplibs="$deplib $deplibs"
5187             else
5188               compile_deplibs="$deplib $compile_deplibs"
5189               finalize_deplibs="$deplib $finalize_deplibs"
5190             fi
5191             func_stripname '-L' '' "$deplib"
5192             newlib_search_path="$newlib_search_path $func_stripname_result"
5193             ;;
5194           *)
5195             func_warning "\`-L' is ignored for archives/objects"
5196             ;;
5197           esac # linkmode
5198           continue
5199           ;; # -L
5200         -R*)
5201           if test "$pass" = link; then
5202             func_stripname '-R' '' "$deplib"
5203             dir=$func_stripname_result
5204             # Make sure the xrpath contains only unique directories.
5205             case "$xrpath " in
5206             *" $dir "*) ;;
5207             *) xrpath="$xrpath $dir" ;;
5208             esac
5209           fi
5210           deplibs="$deplib $deplibs"
5211           continue
5212           ;;
5213         *.la) lib="$deplib" ;;
5214         *.$libext)
5215           if test "$pass" = conv; then
5216             deplibs="$deplib $deplibs"
5217             continue
5218           fi
5219           case $linkmode in
5220           lib)
5221             # Linking convenience modules into shared libraries is allowed,
5222             # but linking other static libraries is non-portable.
5223             case " $dlpreconveniencelibs " in
5224             *" $deplib "*) ;;
5225             *)
5226               valid_a_lib=no
5227               case $deplibs_check_method in
5228                 match_pattern*)
5229                   set dummy $deplibs_check_method; shift
5230                   match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
5231                   if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
5232                     | $EGREP "$match_pattern_regex" > /dev/null; then
5233                     valid_a_lib=yes
5234                   fi
5235                 ;;
5236                 pass_all)
5237                   valid_a_lib=yes
5238                 ;;
5239               esac
5240               if test "$valid_a_lib" != yes; then
5241                 $ECHO
5242                 $ECHO "*** Warning: Trying to link with static lib archive $deplib."
5243                 $ECHO "*** I have the capability to make that library automatically link in when"
5244                 $ECHO "*** you link to this library.  But I can only do this if you have a"
5245                 $ECHO "*** shared version of the library, which you do not appear to have"
5246                 $ECHO "*** because the file extensions .$libext of this argument makes me believe"
5247                 $ECHO "*** that it is just a static archive that I should not use here."
5248               else
5249                 $ECHO
5250                 $ECHO "*** Warning: Linking the shared library $output against the"
5251                 $ECHO "*** static library $deplib is not portable!"
5252                 deplibs="$deplib $deplibs"
5253               fi
5254               ;;
5255             esac
5256             continue
5257             ;;
5258           prog)
5259             if test "$pass" != link; then
5260               deplibs="$deplib $deplibs"
5261             else
5262               compile_deplibs="$deplib $compile_deplibs"
5263               finalize_deplibs="$deplib $finalize_deplibs"
5264             fi
5265             continue
5266             ;;
5267           esac # linkmode
5268           ;; # *.$libext
5269         *.lo | *.$objext)
5270           if test "$pass" = conv; then
5271             deplibs="$deplib $deplibs"
5272           elif test "$linkmode" = prog; then
5273             if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
5274               # If there is no dlopen support or we're linking statically,
5275               # we need to preload.
5276               newdlprefiles="$newdlprefiles $deplib"
5277               compile_deplibs="$deplib $compile_deplibs"
5278               finalize_deplibs="$deplib $finalize_deplibs"
5279             else
5280               newdlfiles="$newdlfiles $deplib"
5281             fi
5282           fi
5283           continue
5284           ;;
5285         %DEPLIBS%)
5286           alldeplibs=yes
5287           continue
5288           ;;
5289         esac # case $deplib
5290
5291         if test "$found" = yes || test -f "$lib"; then :
5292         else
5293           func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
5294         fi
5295
5296         # Check to see that this really is a libtool archive.
5297         func_lalib_unsafe_p "$lib" \
5298           || func_fatal_error "\`$lib' is not a valid libtool archive"
5299
5300         func_dirname "$lib" "" "."
5301         ladir="$func_dirname_result"
5302
5303         dlname=
5304         dlopen=
5305         dlpreopen=
5306         libdir=
5307         library_names=
5308         old_library=
5309         inherited_linker_flags=
5310         # If the library was installed with an old release of libtool,
5311         # it will not redefine variables installed, or shouldnotlink
5312         installed=yes
5313         shouldnotlink=no
5314         avoidtemprpath=
5315
5316
5317         # Read the .la file
5318         func_source "$lib"
5319
5320         # Convert "-framework foo" to "foo.ltframework"
5321         if test -n "$inherited_linker_flags"; then
5322           tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
5323           for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
5324             case " $new_inherited_linker_flags " in
5325               *" $tmp_inherited_linker_flag "*) ;;
5326               *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
5327             esac
5328           done
5329         fi
5330         dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5331         if test "$linkmode,$pass" = "lib,link" ||
5332            test "$linkmode,$pass" = "prog,scan" ||
5333            { test "$linkmode" != prog && test "$linkmode" != lib; }; then
5334           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
5335           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
5336         fi
5337
5338         if test "$pass" = conv; then
5339           # Only check for convenience libraries
5340           deplibs="$lib $deplibs"
5341           if test -z "$libdir"; then
5342             if test -z "$old_library"; then
5343               func_fatal_error "cannot find name of link library for \`$lib'"
5344             fi
5345             # It is a libtool convenience library, so add in its objects.
5346             convenience="$convenience $ladir/$objdir/$old_library"
5347             old_convenience="$old_convenience $ladir/$objdir/$old_library"
5348           elif test "$linkmode" != prog && test "$linkmode" != lib; then
5349             func_fatal_error "\`$lib' is not a convenience library"
5350           fi
5351           tmp_libs=
5352           for deplib in $dependency_libs; do
5353             deplibs="$deplib $deplibs"
5354             if $opt_duplicate_deps ; then
5355               case "$tmp_libs " in
5356               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5357               esac
5358             fi
5359             tmp_libs="$tmp_libs $deplib"
5360           done
5361           continue
5362         fi # $pass = conv
5363
5364
5365         # Get the name of the library we link against.
5366         linklib=
5367         for l in $old_library $library_names; do
5368           linklib="$l"
5369         done
5370         if test -z "$linklib"; then
5371           func_fatal_error "cannot find name of link library for \`$lib'"
5372         fi
5373
5374         # This library was specified with -dlopen.
5375         if test "$pass" = dlopen; then
5376           if test -z "$libdir"; then
5377             func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
5378           fi
5379           if test -z "$dlname" ||
5380              test "$dlopen_support" != yes ||
5381              test "$build_libtool_libs" = no; then
5382             # If there is no dlname, no dlopen support or we're linking
5383             # statically, we need to preload.  We also need to preload any
5384             # dependent libraries so libltdl's deplib preloader doesn't
5385             # bomb out in the load deplibs phase.
5386             dlprefiles="$dlprefiles $lib $dependency_libs"
5387           else
5388             newdlfiles="$newdlfiles $lib"
5389           fi
5390           continue
5391         fi # $pass = dlopen
5392
5393         # We need an absolute path.
5394         case $ladir in
5395         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
5396         *)
5397           abs_ladir=`cd "$ladir" && pwd`
5398           if test -z "$abs_ladir"; then
5399             func_warning "cannot determine absolute directory name of \`$ladir'"
5400             func_warning "passing it literally to the linker, although it might fail"
5401             abs_ladir="$ladir"
5402           fi
5403           ;;
5404         esac
5405         func_basename "$lib"
5406         laname="$func_basename_result"
5407
5408         # Find the relevant object directory and library name.
5409         if test "X$installed" = Xyes; then
5410           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5411             func_warning "library \`$lib' was moved."
5412             dir="$ladir"
5413             absdir="$abs_ladir"
5414             libdir="$abs_ladir"
5415           else
5416             dir="$libdir"
5417             absdir="$libdir"
5418           fi
5419           test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
5420         else
5421           if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5422             dir="$ladir"
5423             absdir="$abs_ladir"
5424             # Remove this search path later
5425             notinst_path="$notinst_path $abs_ladir"
5426           else
5427             dir="$ladir/$objdir"
5428             absdir="$abs_ladir/$objdir"
5429             # Remove this search path later
5430             notinst_path="$notinst_path $abs_ladir"
5431           fi
5432         fi # $installed = yes
5433         func_stripname 'lib' '.la' "$laname"
5434         name=$func_stripname_result
5435
5436         # This library was specified with -dlpreopen.
5437         if test "$pass" = dlpreopen; then
5438           if test -z "$libdir" && test "$linkmode" = prog; then
5439             func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
5440           fi
5441           # Prefer using a static library (so that no silly _DYNAMIC symbols
5442           # are required to link).
5443           if test -n "$old_library"; then
5444             newdlprefiles="$newdlprefiles $dir/$old_library"
5445             # Keep a list of preopened convenience libraries to check
5446             # that they are being used correctly in the link pass.
5447             test -z "$libdir" && \
5448                 dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
5449           # Otherwise, use the dlname, so that lt_dlopen finds it.
5450           elif test -n "$dlname"; then
5451             newdlprefiles="$newdlprefiles $dir/$dlname"
5452           else
5453             newdlprefiles="$newdlprefiles $dir/$linklib"
5454           fi
5455         fi # $pass = dlpreopen
5456
5457         if test -z "$libdir"; then
5458           # Link the convenience library
5459           if test "$linkmode" = lib; then
5460             deplibs="$dir/$old_library $deplibs"
5461           elif test "$linkmode,$pass" = "prog,link"; then
5462             compile_deplibs="$dir/$old_library $compile_deplibs"
5463             finalize_deplibs="$dir/$old_library $finalize_deplibs"
5464           else
5465             deplibs="$lib $deplibs" # used for prog,scan pass
5466           fi
5467           continue
5468         fi
5469
5470
5471         if test "$linkmode" = prog && test "$pass" != link; then
5472           newlib_search_path="$newlib_search_path $ladir"
5473           deplibs="$lib $deplibs"
5474
5475           linkalldeplibs=no
5476           if test "$link_all_deplibs" != no || test -z "$library_names" ||
5477              test "$build_libtool_libs" = no; then
5478             linkalldeplibs=yes
5479           fi
5480
5481           tmp_libs=
5482           for deplib in $dependency_libs; do
5483             case $deplib in
5484             -L*) func_stripname '-L' '' "$deplib"
5485                  newlib_search_path="$newlib_search_path $func_stripname_result"
5486                  ;;
5487             esac
5488             # Need to link against all dependency_libs?
5489             if test "$linkalldeplibs" = yes; then
5490               deplibs="$deplib $deplibs"
5491             else
5492               # Need to hardcode shared library paths
5493               # or/and link against static libraries
5494               newdependency_libs="$deplib $newdependency_libs"
5495             fi
5496             if $opt_duplicate_deps ; then
5497               case "$tmp_libs " in
5498               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5499               esac
5500             fi
5501             tmp_libs="$tmp_libs $deplib"
5502           done # for deplib
5503           continue
5504         fi # $linkmode = prog...
5505
5506         if test "$linkmode,$pass" = "prog,link"; then
5507           if test -n "$library_names" &&
5508              { { test "$prefer_static_libs" = no ||
5509                  test "$prefer_static_libs,$installed" = "built,yes"; } ||
5510                test -z "$old_library"; }; then
5511             # We need to hardcode the library path
5512             if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
5513               # Make sure the rpath contains only unique directories.
5514               case "$temp_rpath:" in
5515               *"$absdir:"*) ;;
5516               *) temp_rpath="$temp_rpath$absdir:" ;;
5517               esac
5518             fi
5519
5520             # Hardcode the library path.
5521             # Skip directories that are in the system default run-time
5522             # search path.
5523             case " $sys_lib_dlsearch_path " in
5524             *" $absdir "*) ;;
5525             *)
5526               case "$compile_rpath " in
5527               *" $absdir "*) ;;
5528               *) compile_rpath="$compile_rpath $absdir"
5529               esac
5530               ;;
5531             esac
5532             case " $sys_lib_dlsearch_path " in
5533             *" $libdir "*) ;;
5534             *)
5535               case "$finalize_rpath " in
5536               *" $libdir "*) ;;
5537               *) finalize_rpath="$finalize_rpath $libdir"
5538               esac
5539               ;;
5540             esac
5541           fi # $linkmode,$pass = prog,link...
5542
5543           if test "$alldeplibs" = yes &&
5544              { test "$deplibs_check_method" = pass_all ||
5545                { test "$build_libtool_libs" = yes &&
5546                  test -n "$library_names"; }; }; then
5547             # We only need to search for static libraries
5548             continue
5549           fi
5550         fi
5551
5552         link_static=no # Whether the deplib will be linked statically
5553         use_static_libs=$prefer_static_libs
5554         if test "$use_static_libs" = built && test "$installed" = yes; then
5555           use_static_libs=no
5556         fi
5557         if test -n "$library_names" &&
5558            { test "$use_static_libs" = no || test -z "$old_library"; }; then
5559           case $host in
5560           *cygwin* | *mingw* | *cegcc*)
5561               # No point in relinking DLLs because paths are not encoded
5562               notinst_deplibs="$notinst_deplibs $lib"
5563               need_relink=no
5564             ;;
5565           *)
5566             if test "$installed" = no; then
5567               notinst_deplibs="$notinst_deplibs $lib"
5568               need_relink=yes
5569             fi
5570             ;;
5571           esac
5572           # This is a shared library
5573
5574           # Warn about portability, can't link against -module's on some
5575           # systems (darwin).  Don't bleat about dlopened modules though!
5576           dlopenmodule=""
5577           for dlpremoduletest in $dlprefiles; do
5578             if test "X$dlpremoduletest" = "X$lib"; then
5579               dlopenmodule="$dlpremoduletest"
5580               break
5581             fi
5582           done
5583           if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
5584             $ECHO
5585             if test "$linkmode" = prog; then
5586               $ECHO "*** Warning: Linking the executable $output against the loadable module"
5587             else
5588               $ECHO "*** Warning: Linking the shared library $output against the loadable module"
5589             fi
5590             $ECHO "*** $linklib is not portable!"
5591           fi
5592           if test "$linkmode" = lib &&
5593              test "$hardcode_into_libs" = yes; then
5594             # Hardcode the library path.
5595             # Skip directories that are in the system default run-time
5596             # search path.
5597             case " $sys_lib_dlsearch_path " in
5598             *" $absdir "*) ;;
5599             *)
5600               case "$compile_rpath " in
5601               *" $absdir "*) ;;
5602               *) compile_rpath="$compile_rpath $absdir"
5603               esac
5604               ;;
5605             esac
5606             case " $sys_lib_dlsearch_path " in
5607             *" $libdir "*) ;;
5608             *)
5609               case "$finalize_rpath " in
5610               *" $libdir "*) ;;
5611               *) finalize_rpath="$finalize_rpath $libdir"
5612               esac
5613               ;;
5614             esac
5615           fi
5616
5617           if test -n "$old_archive_from_expsyms_cmds"; then
5618             # figure out the soname
5619             set dummy $library_names
5620             shift
5621             realname="$1"
5622             shift
5623             libname=`eval "\\$ECHO \"$libname_spec\""`
5624             # use dlname if we got it. it's perfectly good, no?
5625             if test -n "$dlname"; then
5626               soname="$dlname"
5627             elif test -n "$soname_spec"; then
5628               # bleh windows
5629               case $host in
5630               *cygwin* | mingw* | *cegcc*)
5631                 func_arith $current - $age
5632                 major=$func_arith_result
5633                 versuffix="-$major"
5634                 ;;
5635               esac
5636               eval soname=\"$soname_spec\"
5637             else
5638               soname="$realname"
5639             fi
5640
5641             # Make a new name for the extract_expsyms_cmds to use
5642             soroot="$soname"
5643             func_basename "$soroot"
5644             soname="$func_basename_result"
5645             func_stripname 'lib' '.dll' "$soname"
5646             newlib=libimp-$func_stripname_result.a
5647
5648             # If the library has no export list, then create one now
5649             if test -f "$output_objdir/$soname-def"; then :
5650             else
5651               func_verbose "extracting exported symbol list from \`$soname'"
5652               func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
5653             fi
5654
5655             # Create $newlib
5656             if test -f "$output_objdir/$newlib"; then :; else
5657               func_verbose "generating import library for \`$soname'"
5658               func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
5659             fi
5660             # make sure the library variables are pointing to the new library
5661             dir=$output_objdir
5662             linklib=$newlib
5663           fi # test -n "$old_archive_from_expsyms_cmds"
5664
5665           if test "$linkmode" = prog || test "$mode" != relink; then
5666             add_shlibpath=
5667             add_dir=
5668             add=
5669             lib_linked=yes
5670             case $hardcode_action in
5671             immediate | unsupported)
5672               if test "$hardcode_direct" = no; then
5673                 add="$dir/$linklib"
5674                 case $host in
5675                   *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
5676                   *-*-sysv4*uw2*) add_dir="-L$dir" ;;
5677                   *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
5678                     *-*-unixware7*) add_dir="-L$dir" ;;
5679                   *-*-darwin* )
5680                     # if the lib is a (non-dlopened) module then we can not
5681                     # link against it, someone is ignoring the earlier warnings
5682                     if /usr/bin/file -L $add 2> /dev/null |
5683                          $GREP ": [^:]* bundle" >/dev/null ; then
5684                       if test "X$dlopenmodule" != "X$lib"; then
5685                         $ECHO "*** Warning: lib $linklib is a module, not a shared library"
5686                         if test -z "$old_library" ; then
5687                           $ECHO
5688                           $ECHO "*** And there doesn't seem to be a static archive available"
5689                           $ECHO "*** The link will probably fail, sorry"
5690                         else
5691                           add="$dir/$old_library"
5692                         fi
5693                       elif test -n "$old_library"; then
5694                         add="$dir/$old_library"
5695                       fi
5696                     fi
5697                 esac
5698               elif test "$hardcode_minus_L" = no; then
5699                 case $host in
5700                 *-*-sunos*) add_shlibpath="$dir" ;;
5701                 esac
5702                 add_dir="-L$dir"
5703                 add="-l$name"
5704               elif test "$hardcode_shlibpath_var" = no; then
5705                 add_shlibpath="$dir"
5706                 add="-l$name"
5707               else
5708                 lib_linked=no
5709               fi
5710               ;;
5711             relink)
5712               if test "$hardcode_direct" = yes &&
5713                  test "$hardcode_direct_absolute" = no; then
5714                 add="$dir/$linklib"
5715               elif test "$hardcode_minus_L" = yes; then
5716                 add_dir="-L$dir"
5717                 # Try looking first in the location we're being installed to.
5718                 if test -n "$inst_prefix_dir"; then
5719                   case $libdir in
5720                     [\\/]*)
5721                       add_dir="$add_dir -L$inst_prefix_dir$libdir"
5722                       ;;
5723                   esac
5724                 fi
5725                 add="-l$name"
5726               elif test "$hardcode_shlibpath_var" = yes; then
5727                 add_shlibpath="$dir"
5728                 add="-l$name"
5729               else
5730                 lib_linked=no
5731               fi
5732               ;;
5733             *) lib_linked=no ;;
5734             esac
5735
5736             if test "$lib_linked" != yes; then
5737               func_fatal_configuration "unsupported hardcode properties"
5738             fi
5739
5740             if test -n "$add_shlibpath"; then
5741               case :$compile_shlibpath: in
5742               *":$add_shlibpath:"*) ;;
5743               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
5744               esac
5745             fi
5746             if test "$linkmode" = prog; then
5747               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
5748               test -n "$add" && compile_deplibs="$add $compile_deplibs"
5749             else
5750               test -n "$add_dir" && deplibs="$add_dir $deplibs"
5751               test -n "$add" && deplibs="$add $deplibs"
5752               if test "$hardcode_direct" != yes &&
5753                  test "$hardcode_minus_L" != yes &&
5754                  test "$hardcode_shlibpath_var" = yes; then
5755                 case :$finalize_shlibpath: in
5756                 *":$libdir:"*) ;;
5757                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5758                 esac
5759               fi
5760             fi
5761           fi
5762
5763           if test "$linkmode" = prog || test "$mode" = relink; then
5764             add_shlibpath=
5765             add_dir=
5766             add=
5767             # Finalize command for both is simple: just hardcode it.
5768             if test "$hardcode_direct" = yes &&
5769                test "$hardcode_direct_absolute" = no; then
5770               add="$libdir/$linklib"
5771             elif test "$hardcode_minus_L" = yes; then
5772               add_dir="-L$libdir"
5773               add="-l$name"
5774             elif test "$hardcode_shlibpath_var" = yes; then
5775               case :$finalize_shlibpath: in
5776               *":$libdir:"*) ;;
5777               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5778               esac
5779               add="-l$name"
5780             elif test "$hardcode_automatic" = yes; then
5781               if test -n "$inst_prefix_dir" &&
5782                  test -f "$inst_prefix_dir$libdir/$linklib" ; then
5783                 add="$inst_prefix_dir$libdir/$linklib"
5784               else
5785                 add="$libdir/$linklib"
5786               fi
5787             else
5788               # We cannot seem to hardcode it, guess we'll fake it.
5789               add_dir="-L$libdir"
5790               # Try looking first in the location we're being installed to.
5791               if test -n "$inst_prefix_dir"; then
5792                 case $libdir in
5793                   [\\/]*)
5794                     add_dir="$add_dir -L$inst_prefix_dir$libdir"
5795                     ;;
5796                 esac
5797               fi
5798               add="-l$name"
5799             fi
5800
5801             if test "$linkmode" = prog; then
5802               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
5803               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
5804             else
5805               test -n "$add_dir" && deplibs="$add_dir $deplibs"
5806               test -n "$add" && deplibs="$add $deplibs"
5807             fi
5808           fi
5809         elif test "$linkmode" = prog; then
5810           # Here we assume that one of hardcode_direct or hardcode_minus_L
5811           # is not unsupported.  This is valid on all known static and
5812           # shared platforms.
5813           if test "$hardcode_direct" != unsupported; then
5814             test -n "$old_library" && linklib="$old_library"
5815             compile_deplibs="$dir/$linklib $compile_deplibs"
5816             finalize_deplibs="$dir/$linklib $finalize_deplibs"
5817           else
5818             compile_deplibs="-l$name -L$dir $compile_deplibs"
5819             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
5820           fi
5821         elif test "$build_libtool_libs" = yes; then
5822           # Not a shared library
5823           if test "$deplibs_check_method" != pass_all; then
5824             # We're trying link a shared library against a static one
5825             # but the system doesn't support it.
5826
5827             # Just print a warning and add the library to dependency_libs so
5828             # that the program can be linked against the static library.
5829             $ECHO
5830             $ECHO "*** Warning: This system can not link to static lib archive $lib."
5831             $ECHO "*** I have the capability to make that library automatically link in when"
5832             $ECHO "*** you link to this library.  But I can only do this if you have a"
5833             $ECHO "*** shared version of the library, which you do not appear to have."
5834             if test "$module" = yes; then
5835               $ECHO "*** But as you try to build a module library, libtool will still create "
5836               $ECHO "*** a static module, that should work as long as the dlopening application"
5837               $ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
5838               if test -z "$global_symbol_pipe"; then
5839                 $ECHO
5840                 $ECHO "*** However, this would only work if libtool was able to extract symbol"
5841                 $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
5842                 $ECHO "*** not find such a program.  So, this module is probably useless."
5843                 $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
5844               fi
5845               if test "$build_old_libs" = no; then
5846                 build_libtool_libs=module
5847                 build_old_libs=yes
5848               else
5849                 build_libtool_libs=no
5850               fi
5851             fi
5852           else
5853             deplibs="$dir/$old_library $deplibs"
5854             link_static=yes
5855           fi
5856         fi # link shared/static library?
5857
5858         if test "$linkmode" = lib; then
5859           if test -n "$dependency_libs" &&
5860              { test "$hardcode_into_libs" != yes ||
5861                test "$build_old_libs" = yes ||
5862                test "$link_static" = yes; }; then
5863             # Extract -R from dependency_libs
5864             temp_deplibs=
5865             for libdir in $dependency_libs; do
5866               case $libdir in
5867               -R*) func_stripname '-R' '' "$libdir"
5868                    temp_xrpath=$func_stripname_result
5869                    case " $xrpath " in
5870                    *" $temp_xrpath "*) ;;
5871                    *) xrpath="$xrpath $temp_xrpath";;
5872                    esac;;
5873               *) temp_deplibs="$temp_deplibs $libdir";;
5874               esac
5875             done
5876             dependency_libs="$temp_deplibs"
5877           fi
5878
5879           newlib_search_path="$newlib_search_path $absdir"
5880           # Link against this library
5881           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
5882           # ... and its dependency_libs
5883           tmp_libs=
5884           for deplib in $dependency_libs; do
5885             newdependency_libs="$deplib $newdependency_libs"
5886             if $opt_duplicate_deps ; then
5887               case "$tmp_libs " in
5888               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5889               esac
5890             fi
5891             tmp_libs="$tmp_libs $deplib"
5892           done
5893
5894           if test "$link_all_deplibs" != no; then
5895             # Add the search paths of all dependency libraries
5896             for deplib in $dependency_libs; do
5897               case $deplib in
5898               -L*) path="$deplib" ;;
5899               *.la)
5900                 func_dirname "$deplib" "" "."
5901                 dir="$func_dirname_result"
5902                 # We need an absolute path.
5903                 case $dir in
5904                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
5905                 *)
5906                   absdir=`cd "$dir" && pwd`
5907                   if test -z "$absdir"; then
5908                     func_warning "cannot determine absolute directory name of \`$dir'"
5909                     absdir="$dir"
5910                   fi
5911                   ;;
5912                 esac
5913                 if $GREP "^installed=no" $deplib > /dev/null; then
5914                 case $host in
5915                 *-*-darwin*)
5916                   depdepl=
5917                   eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
5918                   if test -n "$deplibrary_names" ; then
5919                     for tmp in $deplibrary_names ; do
5920                       depdepl=$tmp
5921                     done
5922                     if test -f "$absdir/$objdir/$depdepl" ; then
5923                       depdepl="$absdir/$objdir/$depdepl"
5924                       darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
5925                       if test -z "$darwin_install_name"; then
5926                           darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
5927                       fi
5928                       compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
5929                       linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
5930                       path=
5931                     fi
5932                   fi
5933                   ;;
5934                 *)
5935                   path="-L$absdir/$objdir"
5936                   ;;
5937                 esac
5938                 else
5939                   eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5940                   test -z "$libdir" && \
5941                     func_fatal_error "\`$deplib' is not a valid libtool archive"
5942                   test "$absdir" != "$libdir" && \
5943                     func_warning "\`$deplib' seems to be moved"
5944
5945                   path="-L$absdir"
5946                 fi
5947                 ;;
5948               esac
5949               case " $deplibs " in
5950               *" $path "*) ;;
5951               *) deplibs="$path $deplibs" ;;
5952               esac
5953             done
5954           fi # link_all_deplibs != no
5955         fi # linkmode = lib
5956       done # for deplib in $libs
5957       if test "$pass" = link; then
5958         if test "$linkmode" = "prog"; then
5959           compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
5960           finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
5961         else
5962           compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5963         fi
5964       fi
5965       dependency_libs="$newdependency_libs"
5966       if test "$pass" = dlpreopen; then
5967         # Link the dlpreopened libraries before other libraries
5968         for deplib in $save_deplibs; do
5969           deplibs="$deplib $deplibs"
5970         done
5971       fi
5972       if test "$pass" != dlopen; then
5973         if test "$pass" != conv; then
5974           # Make sure lib_search_path contains only unique directories.
5975           lib_search_path=
5976           for dir in $newlib_search_path; do
5977             case "$lib_search_path " in
5978             *" $dir "*) ;;
5979             *) lib_search_path="$lib_search_path $dir" ;;
5980             esac
5981           done
5982           newlib_search_path=
5983         fi
5984
5985         if test "$linkmode,$pass" != "prog,link"; then
5986           vars="deplibs"
5987         else
5988           vars="compile_deplibs finalize_deplibs"
5989         fi
5990         for var in $vars dependency_libs; do
5991           # Add libraries to $var in reverse order
5992           eval tmp_libs=\"\$$var\"
5993           new_libs=
5994           for deplib in $tmp_libs; do
5995             # FIXME: Pedantically, this is the right thing to do, so
5996             #        that some nasty dependency loop isn't accidentally
5997             #        broken:
5998             #new_libs="$deplib $new_libs"
5999             # Pragmatically, this seems to cause very few problems in
6000             # practice:
6001             case $deplib in
6002             -L*) new_libs="$deplib $new_libs" ;;
6003             -R*) ;;
6004             *)
6005               # And here is the reason: when a library appears more
6006               # than once as an explicit dependence of a library, or
6007               # is implicitly linked in more than once by the
6008               # compiler, it is considered special, and multiple
6009               # occurrences thereof are not removed.  Compare this
6010               # with having the same library being listed as a
6011               # dependency of multiple other libraries: in this case,
6012               # we know (pedantically, we assume) the library does not
6013               # need to be listed more than once, so we keep only the
6014               # last copy.  This is not always right, but it is rare
6015               # enough that we require users that really mean to play
6016               # such unportable linking tricks to link the library
6017               # using -Wl,-lname, so that libtool does not consider it
6018               # for duplicate removal.
6019               case " $specialdeplibs " in
6020               *" $deplib "*) new_libs="$deplib $new_libs" ;;
6021               *)
6022                 case " $new_libs " in
6023                 *" $deplib "*) ;;
6024                 *) new_libs="$deplib $new_libs" ;;
6025                 esac
6026                 ;;
6027               esac
6028               ;;
6029             esac
6030           done
6031           tmp_libs=
6032           for deplib in $new_libs; do
6033             case $deplib in
6034             -L*)
6035               case " $tmp_libs " in
6036               *" $deplib "*) ;;
6037               *) tmp_libs="$tmp_libs $deplib" ;;
6038               esac
6039               ;;
6040             *) tmp_libs="$tmp_libs $deplib" ;;
6041             esac
6042           done
6043           eval $var=\"$tmp_libs\"
6044         done # for var
6045       fi
6046       # Last step: remove runtime libs from dependency_libs
6047       # (they stay in deplibs)
6048       tmp_libs=
6049       for i in $dependency_libs ; do
6050         case " $predeps $postdeps $compiler_lib_search_path " in
6051         *" $i "*)
6052           i=""
6053           ;;
6054         esac
6055         if test -n "$i" ; then
6056           tmp_libs="$tmp_libs $i"
6057         fi
6058       done
6059       dependency_libs=$tmp_libs
6060     done # for pass
6061     if test "$linkmode" = prog; then
6062       dlfiles="$newdlfiles"
6063     fi
6064     if test "$linkmode" = prog || test "$linkmode" = lib; then
6065       dlprefiles="$newdlprefiles"
6066     fi
6067
6068     case $linkmode in
6069     oldlib)
6070       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
6071         func_warning "\`-dlopen' is ignored for archives"
6072       fi
6073
6074       case " $deplibs" in
6075       *\ -l* | *\ -L*)
6076         func_warning "\`-l' and \`-L' are ignored for archives" ;;
6077       esac
6078
6079       test -n "$rpath" && \
6080         func_warning "\`-rpath' is ignored for archives"
6081
6082       test -n "$xrpath" && \
6083         func_warning "\`-R' is ignored for archives"
6084
6085       test -n "$vinfo" && \
6086         func_warning "\`-version-info/-version-number' is ignored for archives"
6087
6088       test -n "$release" && \
6089         func_warning "\`-release' is ignored for archives"
6090
6091       test -n "$export_symbols$export_symbols_regex" && \
6092         func_warning "\`-export-symbols' is ignored for archives"
6093
6094       # Now set the variables for building old libraries.
6095       build_libtool_libs=no
6096       oldlibs="$output"
6097       objs="$objs$old_deplibs"
6098       ;;
6099
6100     lib)
6101       # Make sure we only generate libraries of the form `libNAME.la'.
6102       case $outputname in
6103       lib*)
6104         func_stripname 'lib' '.la' "$outputname"
6105         name=$func_stripname_result
6106         eval shared_ext=\"$shrext_cmds\"
6107         eval libname=\"$libname_spec\"
6108         ;;
6109       *)
6110         test "$module" = no && \
6111           func_fatal_help "libtool library \`$output' must begin with \`lib'"
6112
6113         if test "$need_lib_prefix" != no; then
6114           # Add the "lib" prefix for modules if required
6115           func_stripname '' '.la' "$outputname"
6116           name=$func_stripname_result
6117           eval shared_ext=\"$shrext_cmds\"
6118           eval libname=\"$libname_spec\"
6119         else
6120           func_stripname '' '.la' "$outputname"
6121           libname=$func_stripname_result
6122         fi
6123         ;;
6124       esac
6125
6126       if test -n "$objs"; then
6127         if test "$deplibs_check_method" != pass_all; then
6128           func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
6129         else
6130           $ECHO
6131           $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
6132           $ECHO "*** objects $objs is not portable!"
6133           libobjs="$libobjs $objs"
6134         fi
6135       fi
6136
6137       test "$dlself" != no && \
6138         func_warning "\`-dlopen self' is ignored for libtool libraries"
6139
6140       set dummy $rpath
6141       shift
6142       test "$#" -gt 1 && \
6143         func_warning "ignoring multiple \`-rpath's for a libtool library"
6144
6145       install_libdir="$1"
6146
6147       oldlibs=
6148       if test -z "$rpath"; then
6149         if test "$build_libtool_libs" = yes; then
6150           # Building a libtool convenience library.
6151           # Some compilers have problems with a `.al' extension so
6152           # convenience libraries should have the same extension an
6153           # archive normally would.
6154           oldlibs="$output_objdir/$libname.$libext $oldlibs"
6155           build_libtool_libs=convenience
6156           build_old_libs=yes
6157         fi
6158
6159         test -n "$vinfo" && \
6160           func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
6161
6162         test -n "$release" && \
6163           func_warning "\`-release' is ignored for convenience libraries"
6164       else
6165
6166         # Parse the version information argument.
6167         save_ifs="$IFS"; IFS=':'
6168         set dummy $vinfo 0 0 0
6169         shift
6170         IFS="$save_ifs"
6171
6172         test -n "$7" && \
6173           func_fatal_help "too many parameters to \`-version-info'"
6174
6175         # convert absolute version numbers to libtool ages
6176         # this retains compatibility with .la files and attempts
6177         # to make the code below a bit more comprehensible
6178
6179         case $vinfo_number in
6180         yes)
6181           number_major="$1"
6182           number_minor="$2"
6183           number_revision="$3"
6184           #
6185           # There are really only two kinds -- those that
6186           # use the current revision as the major version
6187           # and those that subtract age and use age as
6188           # a minor version.  But, then there is irix
6189           # which has an extra 1 added just for fun
6190           #
6191           case $version_type in
6192           darwin|linux|osf|windows|none)
6193             func_arith $number_major + $number_minor
6194             current=$func_arith_result
6195             age="$number_minor"
6196             revision="$number_revision"
6197             ;;
6198           freebsd-aout|freebsd-elf|sunos)
6199             current="$number_major"
6200             revision="$number_minor"
6201             age="0"
6202             ;;
6203           irix|nonstopux)
6204             func_arith $number_major + $number_minor
6205             current=$func_arith_result
6206             age="$number_minor"
6207             revision="$number_minor"
6208             lt_irix_increment=no
6209             ;;
6210           esac
6211           ;;
6212         no)
6213           current="$1"
6214           revision="$2"
6215           age="$3"
6216           ;;
6217         esac
6218
6219         # Check that each of the things are valid numbers.
6220         case $current in
6221         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]) ;;
6222         *)
6223           func_error "CURRENT \`$current' must be a nonnegative integer"
6224           func_fatal_error "\`$vinfo' is not valid version information"
6225           ;;
6226         esac
6227
6228         case $revision in
6229         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]) ;;
6230         *)
6231           func_error "REVISION \`$revision' must be a nonnegative integer"
6232           func_fatal_error "\`$vinfo' is not valid version information"
6233           ;;
6234         esac
6235
6236         case $age in
6237         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]) ;;
6238         *)
6239           func_error "AGE \`$age' must be a nonnegative integer"
6240           func_fatal_error "\`$vinfo' is not valid version information"
6241           ;;
6242         esac
6243
6244         if test "$age" -gt "$current"; then
6245           func_error "AGE \`$age' is greater than the current interface number \`$current'"
6246           func_fatal_error "\`$vinfo' is not valid version information"
6247         fi
6248
6249         # Calculate the version variables.
6250         major=
6251         versuffix=
6252         verstring=
6253         case $version_type in
6254         none) ;;
6255
6256         darwin)
6257           # Like Linux, but with the current version available in
6258           # verstring for coding it into the library header
6259           func_arith $current - $age
6260           major=.$func_arith_result
6261           versuffix="$major.$age.$revision"
6262           # Darwin ld doesn't like 0 for these options...
6263           func_arith $current + 1
6264           minor_current=$func_arith_result
6265           xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
6266           verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
6267           ;;
6268
6269         freebsd-aout)
6270           major=".$current"
6271           versuffix=".$current.$revision";
6272           ;;
6273
6274         freebsd-elf)
6275           major=".$current"
6276           versuffix=".$current"
6277           ;;
6278
6279         irix | nonstopux)
6280           if test "X$lt_irix_increment" = "Xno"; then
6281             func_arith $current - $age
6282           else
6283             func_arith $current - $age + 1
6284           fi
6285           major=$func_arith_result
6286
6287           case $version_type in
6288             nonstopux) verstring_prefix=nonstopux ;;
6289             *)         verstring_prefix=sgi ;;
6290           esac
6291           verstring="$verstring_prefix$major.$revision"
6292
6293           # Add in all the interfaces that we are compatible with.
6294           loop=$revision
6295           while test "$loop" -ne 0; do
6296             func_arith $revision - $loop
6297             iface=$func_arith_result
6298             func_arith $loop - 1
6299             loop=$func_arith_result
6300             verstring="$verstring_prefix$major.$iface:$verstring"
6301           done
6302
6303           # Before this point, $major must not contain `.'.
6304           major=.$major
6305           versuffix="$major.$revision"
6306           ;;
6307
6308         linux)
6309           func_arith $current - $age
6310           major=.$func_arith_result
6311           versuffix="$major.$age.$revision"
6312           ;;
6313
6314         osf)
6315           func_arith $current - $age
6316           major=.$func_arith_result
6317           versuffix=".$current.$age.$revision"
6318           verstring="$current.$age.$revision"
6319
6320           # Add in all the interfaces that we are compatible with.
6321           loop=$age
6322           while test "$loop" -ne 0; do
6323             func_arith $current - $loop
6324             iface=$func_arith_result
6325             func_arith $loop - 1
6326             loop=$func_arith_result
6327             verstring="$verstring:${iface}.0"
6328           done
6329
6330           # Make executables depend on our current version.
6331           verstring="$verstring:${current}.0"
6332           ;;
6333
6334         qnx)
6335           major=".$current"
6336           versuffix=".$current"
6337           ;;
6338
6339         sunos)
6340           major=".$current"
6341           versuffix=".$current.$revision"
6342           ;;
6343
6344         windows)
6345           # Use '-' rather than '.', since we only want one
6346           # extension on DOS 8.3 filesystems.
6347           func_arith $current - $age
6348           major=$func_arith_result
6349           versuffix="-$major"
6350           ;;
6351
6352         *)
6353           func_fatal_configuration "unknown library version type \`$version_type'"
6354           ;;
6355         esac
6356
6357         # Clear the version info if we defaulted, and they specified a release.
6358         if test -z "$vinfo" && test -n "$release"; then
6359           major=
6360           case $version_type in
6361           darwin)
6362             # we can't check for "0.0" in archive_cmds due to quoting
6363             # problems, so we reset it completely
6364             verstring=
6365             ;;
6366           *)
6367             verstring="0.0"
6368             ;;
6369           esac
6370           if test "$need_version" = no; then
6371             versuffix=
6372           else
6373             versuffix=".0.0"
6374           fi
6375         fi
6376
6377         # Remove version info from name if versioning should be avoided
6378         if test "$avoid_version" = yes && test "$need_version" = no; then
6379           major=
6380           versuffix=
6381           verstring=""
6382         fi
6383
6384         # Check to see if the archive will have undefined symbols.
6385         if test "$allow_undefined" = yes; then
6386           if test "$allow_undefined_flag" = unsupported; then
6387             func_warning "undefined symbols not allowed in $host shared libraries"
6388             build_libtool_libs=no
6389             build_old_libs=yes
6390           fi
6391         else
6392           # Don't allow undefined symbols.
6393           allow_undefined_flag="$no_undefined_flag"
6394         fi
6395
6396       fi
6397
6398       func_generate_dlsyms "$libname" "$libname" "yes"
6399       libobjs="$libobjs $symfileobj"
6400       test "X$libobjs" = "X " && libobjs=
6401
6402       if test "$mode" != relink; then
6403         # Remove our outputs, but don't remove object files since they
6404         # may have been created when compiling PIC objects.
6405         removelist=
6406         tempremovelist=`$ECHO "$output_objdir/*"`
6407         for p in $tempremovelist; do
6408           case $p in
6409             *.$objext | *.gcno)
6410                ;;
6411             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
6412                if test "X$precious_files_regex" != "X"; then
6413                  if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
6414                  then
6415                    continue
6416                  fi
6417                fi
6418                removelist="$removelist $p"
6419                ;;
6420             *) ;;
6421           esac
6422         done
6423         test -n "$removelist" && \
6424           func_show_eval "${RM}r \$removelist"
6425       fi
6426
6427       # Now set the variables for building old libraries.
6428       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
6429         oldlibs="$oldlibs $output_objdir/$libname.$libext"
6430
6431         # Transform .lo files to .o files.
6432         oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
6433       fi
6434
6435       # Eliminate all temporary directories.
6436       #for path in $notinst_path; do
6437       # lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
6438       # deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
6439       # dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
6440       #done
6441
6442       if test -n "$xrpath"; then
6443         # If the user specified any rpath flags, then add them.
6444         temp_xrpath=
6445         for libdir in $xrpath; do
6446           temp_xrpath="$temp_xrpath -R$libdir"
6447           case "$finalize_rpath " in
6448           *" $libdir "*) ;;
6449           *) finalize_rpath="$finalize_rpath $libdir" ;;
6450           esac
6451         done
6452         if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
6453           dependency_libs="$temp_xrpath $dependency_libs"
6454         fi
6455       fi
6456
6457       # Make sure dlfiles contains only unique files that won't be dlpreopened
6458       old_dlfiles="$dlfiles"
6459       dlfiles=
6460       for lib in $old_dlfiles; do
6461         case " $dlprefiles $dlfiles " in
6462         *" $lib "*) ;;
6463         *) dlfiles="$dlfiles $lib" ;;
6464         esac
6465       done
6466
6467       # Make sure dlprefiles contains only unique files
6468       old_dlprefiles="$dlprefiles"
6469       dlprefiles=
6470       for lib in $old_dlprefiles; do
6471         case "$dlprefiles " in
6472         *" $lib "*) ;;
6473         *) dlprefiles="$dlprefiles $lib" ;;
6474         esac
6475       done
6476
6477       if test "$build_libtool_libs" = yes; then
6478         if test -n "$rpath"; then
6479           case $host in
6480           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
6481             # these systems don't actually have a c library (as such)!
6482             ;;
6483           *-*-rhapsody* | *-*-darwin1.[012])
6484             # Rhapsody C library is in the System framework
6485             deplibs="$deplibs System.ltframework"
6486             ;;
6487           *-*-netbsd*)
6488             # Don't link with libc until the a.out ld.so is fixed.
6489             ;;
6490           *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
6491             # Do not include libc due to us having libc/libc_r.
6492             ;;
6493           *-*-sco3.2v5* | *-*-sco5v6*)
6494             # Causes problems with __ctype
6495             ;;
6496           *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
6497             # Compiler inserts libc in the correct place for threads to work
6498             ;;
6499           *)
6500             # Add libc to deplibs on all other systems if necessary.
6501             if test "$build_libtool_need_lc" = "yes"; then
6502               deplibs="$deplibs -lc"
6503             fi
6504             ;;
6505           esac
6506         fi
6507
6508         # Transform deplibs into only deplibs that can be linked in shared.
6509         name_save=$name
6510         libname_save=$libname
6511         release_save=$release
6512         versuffix_save=$versuffix
6513         major_save=$major
6514         # I'm not sure if I'm treating the release correctly.  I think
6515         # release should show up in the -l (ie -lgmp5) so we don't want to
6516         # add it in twice.  Is that correct?
6517         release=""
6518         versuffix=""
6519         major=""
6520         newdeplibs=
6521         droppeddeps=no
6522         case $deplibs_check_method in
6523         pass_all)
6524           # Don't check for shared/static.  Everything works.
6525           # This might be a little naive.  We might want to check
6526           # whether the library exists or not.  But this is on
6527           # osf3 & osf4 and I'm not really sure... Just
6528           # implementing what was already the behavior.
6529           newdeplibs=$deplibs
6530           ;;
6531         test_compile)
6532           # This code stresses the "libraries are programs" paradigm to its
6533           # limits. Maybe even breaks it.  We compile a program, linking it
6534           # against the deplibs as a proxy for the library.  Then we can check
6535           # whether they linked in statically or dynamically with ldd.
6536           $opt_dry_run || $RM conftest.c
6537           cat > conftest.c <<EOF
6538           int main() { return 0; }
6539 EOF
6540           $opt_dry_run || $RM conftest
6541           if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
6542             ldd_output=`ldd conftest`
6543             for i in $deplibs; do
6544               case $i in
6545               -l*)
6546                 func_stripname -l '' "$i"
6547                 name=$func_stripname_result
6548                 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6549                   case " $predeps $postdeps " in
6550                   *" $i "*)
6551                     newdeplibs="$newdeplibs $i"
6552                     i=""
6553                     ;;
6554                   esac
6555                 fi
6556                 if test -n "$i" ; then
6557                   libname=`eval "\\$ECHO \"$libname_spec\""`
6558                   deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6559                   set dummy $deplib_matches; shift
6560                   deplib_match=$1
6561                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6562                     newdeplibs="$newdeplibs $i"
6563                   else
6564                     droppeddeps=yes
6565                     $ECHO
6566                     $ECHO "*** Warning: dynamic linker does not accept needed library $i."
6567                     $ECHO "*** I have the capability to make that library automatically link in when"
6568                     $ECHO "*** you link to this library.  But I can only do this if you have a"
6569                     $ECHO "*** shared version of the library, which I believe you do not have"
6570                     $ECHO "*** because a test_compile did reveal that the linker did not use it for"
6571                     $ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
6572                   fi
6573                 fi
6574                 ;;
6575               *)
6576                 newdeplibs="$newdeplibs $i"
6577                 ;;
6578               esac
6579             done
6580           else
6581             # Error occurred in the first compile.  Let's try to salvage
6582             # the situation: Compile a separate program for each library.
6583             for i in $deplibs; do
6584               case $i in
6585               -l*)
6586                 func_stripname -l '' "$i"
6587                 name=$func_stripname_result
6588                 $opt_dry_run || $RM conftest
6589                 if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
6590                   ldd_output=`ldd conftest`
6591                   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6592                     case " $predeps $postdeps " in
6593                     *" $i "*)
6594                       newdeplibs="$newdeplibs $i"
6595                       i=""
6596                       ;;
6597                     esac
6598                   fi
6599                   if test -n "$i" ; then
6600                     libname=`eval "\\$ECHO \"$libname_spec\""`
6601                     deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6602                     set dummy $deplib_matches; shift
6603                     deplib_match=$1
6604                     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6605                       newdeplibs="$newdeplibs $i"
6606                     else
6607                       droppeddeps=yes
6608                       $ECHO
6609                       $ECHO "*** Warning: dynamic linker does not accept needed library $i."
6610                       $ECHO "*** I have the capability to make that library automatically link in when"
6611                       $ECHO "*** you link to this library.  But I can only do this if you have a"
6612                       $ECHO "*** shared version of the library, which you do not appear to have"
6613                       $ECHO "*** because a test_compile did reveal that the linker did not use this one"
6614                       $ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
6615                     fi
6616                   fi
6617                 else
6618                   droppeddeps=yes
6619                   $ECHO
6620                   $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
6621                   $ECHO "*** make it link in!  You will probably need to install it or some"
6622                   $ECHO "*** library that it depends on before this library will be fully"
6623                   $ECHO "*** functional.  Installing it before continuing would be even better."
6624                 fi
6625                 ;;
6626               *)
6627                 newdeplibs="$newdeplibs $i"
6628                 ;;
6629               esac
6630             done
6631           fi
6632           ;;
6633         file_magic*)
6634           set dummy $deplibs_check_method; shift
6635           file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6636           for a_deplib in $deplibs; do
6637             case $a_deplib in
6638             -l*)
6639               func_stripname -l '' "$a_deplib"
6640               name=$func_stripname_result
6641               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6642                 case " $predeps $postdeps " in
6643                 *" $a_deplib "*)
6644                   newdeplibs="$newdeplibs $a_deplib"
6645                   a_deplib=""
6646                   ;;
6647                 esac
6648               fi
6649               if test -n "$a_deplib" ; then
6650                 libname=`eval "\\$ECHO \"$libname_spec\""`
6651                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6652                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6653                   for potent_lib in $potential_libs; do
6654                       # Follow soft links.
6655                       if ls -lLd "$potent_lib" 2>/dev/null |
6656                          $GREP " -> " >/dev/null; then
6657                         continue
6658                       fi
6659                       # The statement above tries to avoid entering an
6660                       # endless loop below, in case of cyclic links.
6661                       # We might still enter an endless loop, since a link
6662                       # loop can be closed while we follow links,
6663                       # but so what?
6664                       potlib="$potent_lib"
6665                       while test -h "$potlib" 2>/dev/null; do
6666                         potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
6667                         case $potliblink in
6668                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
6669                         *) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
6670                         esac
6671                       done
6672                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
6673                          $SED -e 10q |
6674                          $EGREP "$file_magic_regex" > /dev/null; then
6675                         newdeplibs="$newdeplibs $a_deplib"
6676                         a_deplib=""
6677                         break 2
6678                       fi
6679                   done
6680                 done
6681               fi
6682               if test -n "$a_deplib" ; then
6683                 droppeddeps=yes
6684                 $ECHO
6685                 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6686                 $ECHO "*** I have the capability to make that library automatically link in when"
6687                 $ECHO "*** you link to this library.  But I can only do this if you have a"
6688                 $ECHO "*** shared version of the library, which you do not appear to have"
6689                 $ECHO "*** because I did check the linker path looking for a file starting"
6690                 if test -z "$potlib" ; then
6691                   $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
6692                 else
6693                   $ECHO "*** with $libname and none of the candidates passed a file format test"
6694                   $ECHO "*** using a file magic. Last file checked: $potlib"
6695                 fi
6696               fi
6697               ;;
6698             *)
6699               # Add a -L argument.
6700               newdeplibs="$newdeplibs $a_deplib"
6701               ;;
6702             esac
6703           done # Gone through all deplibs.
6704           ;;
6705         match_pattern*)
6706           set dummy $deplibs_check_method; shift
6707           match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6708           for a_deplib in $deplibs; do
6709             case $a_deplib in
6710             -l*)
6711               func_stripname -l '' "$a_deplib"
6712               name=$func_stripname_result
6713               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6714                 case " $predeps $postdeps " in
6715                 *" $a_deplib "*)
6716                   newdeplibs="$newdeplibs $a_deplib"
6717                   a_deplib=""
6718                   ;;
6719                 esac
6720               fi
6721               if test -n "$a_deplib" ; then
6722                 libname=`eval "\\$ECHO \"$libname_spec\""`
6723                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6724                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6725                   for potent_lib in $potential_libs; do
6726                     potlib="$potent_lib" # see symlink-check above in file_magic test
6727                     if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
6728                        $EGREP "$match_pattern_regex" > /dev/null; then
6729                       newdeplibs="$newdeplibs $a_deplib"
6730                       a_deplib=""
6731                       break 2
6732                     fi
6733                   done
6734                 done
6735               fi
6736               if test -n "$a_deplib" ; then
6737                 droppeddeps=yes
6738                 $ECHO
6739                 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6740                 $ECHO "*** I have the capability to make that library automatically link in when"
6741                 $ECHO "*** you link to this library.  But I can only do this if you have a"
6742                 $ECHO "*** shared version of the library, which you do not appear to have"
6743                 $ECHO "*** because I did check the linker path looking for a file starting"
6744                 if test -z "$potlib" ; then
6745                   $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
6746                 else
6747                   $ECHO "*** with $libname and none of the candidates passed a file format test"
6748                   $ECHO "*** using a regex pattern. Last file checked: $potlib"
6749                 fi
6750               fi
6751               ;;
6752             *)
6753               # Add a -L argument.
6754               newdeplibs="$newdeplibs $a_deplib"
6755               ;;
6756             esac
6757           done # Gone through all deplibs.
6758           ;;
6759         none | unknown | *)
6760           newdeplibs=""
6761           tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
6762               -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
6763           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6764             for i in $predeps $postdeps ; do
6765               # can't use Xsed below, because $i might contain '/'
6766               tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
6767             done
6768           fi
6769           if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[      ]//g' |
6770              $GREP . >/dev/null; then
6771             $ECHO
6772             if test "X$deplibs_check_method" = "Xnone"; then
6773               $ECHO "*** Warning: inter-library dependencies are not supported in this platform."
6774             else
6775               $ECHO "*** Warning: inter-library dependencies are not known to be supported."
6776             fi
6777             $ECHO "*** All declared inter-library dependencies are being dropped."
6778             droppeddeps=yes
6779           fi
6780           ;;
6781         esac
6782         versuffix=$versuffix_save
6783         major=$major_save
6784         release=$release_save
6785         libname=$libname_save
6786         name=$name_save
6787
6788         case $host in
6789         *-*-rhapsody* | *-*-darwin1.[012])
6790           # On Rhapsody replace the C library with the System framework
6791           newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
6792           ;;
6793         esac
6794
6795         if test "$droppeddeps" = yes; then
6796           if test "$module" = yes; then
6797             $ECHO
6798             $ECHO "*** Warning: libtool could not satisfy all declared inter-library"
6799             $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
6800             $ECHO "*** a static module, that should work as long as the dlopening"
6801             $ECHO "*** application is linked with the -dlopen flag."
6802             if test -z "$global_symbol_pipe"; then
6803               $ECHO
6804               $ECHO "*** However, this would only work if libtool was able to extract symbol"
6805               $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
6806               $ECHO "*** not find such a program.  So, this module is probably useless."
6807               $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
6808             fi
6809             if test "$build_old_libs" = no; then
6810               oldlibs="$output_objdir/$libname.$libext"
6811               build_libtool_libs=module
6812               build_old_libs=yes
6813             else
6814               build_libtool_libs=no
6815             fi
6816           else
6817             $ECHO "*** The inter-library dependencies that have been dropped here will be"
6818             $ECHO "*** automatically added whenever a program is linked with this library"
6819             $ECHO "*** or is declared to -dlopen it."
6820
6821             if test "$allow_undefined" = no; then
6822               $ECHO
6823               $ECHO "*** Since this library must not contain undefined symbols,"
6824               $ECHO "*** because either the platform does not support them or"
6825               $ECHO "*** it was explicitly requested with -no-undefined,"
6826               $ECHO "*** libtool will only create a static version of it."
6827               if test "$build_old_libs" = no; then
6828                 oldlibs="$output_objdir/$libname.$libext"
6829                 build_libtool_libs=module
6830                 build_old_libs=yes
6831               else
6832                 build_libtool_libs=no
6833               fi
6834             fi
6835           fi
6836         fi
6837         # Done checking deplibs!
6838         deplibs=$newdeplibs
6839       fi
6840       # Time to change all our "foo.ltframework" stuff back to "-framework foo"
6841       case $host in
6842         *-*-darwin*)
6843           newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6844           new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6845           deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6846           ;;
6847       esac
6848
6849       # move library search paths that coincide with paths to not yet
6850       # installed libraries to the beginning of the library search list
6851       new_libs=
6852       for path in $notinst_path; do
6853         case " $new_libs " in
6854         *" -L$path/$objdir "*) ;;
6855         *)
6856           case " $deplibs " in
6857           *" -L$path/$objdir "*)
6858             new_libs="$new_libs -L$path/$objdir" ;;
6859           esac
6860           ;;
6861         esac
6862       done
6863       for deplib in $deplibs; do
6864         case $deplib in
6865         -L*)
6866           case " $new_libs " in
6867           *" $deplib "*) ;;
6868           *) new_libs="$new_libs $deplib" ;;
6869           esac
6870           ;;
6871         *) new_libs="$new_libs $deplib" ;;
6872         esac
6873       done
6874       deplibs="$new_libs"
6875
6876       # All the library-specific variables (install_libdir is set above).
6877       library_names=
6878       old_library=
6879       dlname=
6880
6881       # Test again, we may have decided not to build it any more
6882       if test "$build_libtool_libs" = yes; then
6883         if test "$hardcode_into_libs" = yes; then
6884           # Hardcode the library paths
6885           hardcode_libdirs=
6886           dep_rpath=
6887           rpath="$finalize_rpath"
6888           test "$mode" != relink && rpath="$compile_rpath$rpath"
6889           for libdir in $rpath; do
6890             if test -n "$hardcode_libdir_flag_spec"; then
6891               if test -n "$hardcode_libdir_separator"; then
6892                 if test -z "$hardcode_libdirs"; then
6893                   hardcode_libdirs="$libdir"
6894                 else
6895                   # Just accumulate the unique libdirs.
6896                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
6897                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
6898                     ;;
6899                   *)
6900                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
6901                     ;;
6902                   esac
6903                 fi
6904               else
6905                 eval flag=\"$hardcode_libdir_flag_spec\"
6906                 dep_rpath="$dep_rpath $flag"
6907               fi
6908             elif test -n "$runpath_var"; then
6909               case "$perm_rpath " in
6910               *" $libdir "*) ;;
6911               *) perm_rpath="$perm_rpath $libdir" ;;
6912               esac
6913             fi
6914           done
6915           # Substitute the hardcoded libdirs into the rpath.
6916           if test -n "$hardcode_libdir_separator" &&
6917              test -n "$hardcode_libdirs"; then
6918             libdir="$hardcode_libdirs"
6919             if test -n "$hardcode_libdir_flag_spec_ld"; then
6920               eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
6921             else
6922               eval dep_rpath=\"$hardcode_libdir_flag_spec\"
6923             fi
6924           fi
6925           if test -n "$runpath_var" && test -n "$perm_rpath"; then
6926             # We should set the runpath_var.
6927             rpath=
6928             for dir in $perm_rpath; do
6929               rpath="$rpath$dir:"
6930             done
6931             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
6932           fi
6933           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
6934         fi
6935
6936         shlibpath="$finalize_shlibpath"
6937         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
6938         if test -n "$shlibpath"; then
6939           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
6940         fi
6941
6942         # Get the real and link names of the library.
6943         eval shared_ext=\"$shrext_cmds\"
6944         eval library_names=\"$library_names_spec\"
6945         set dummy $library_names
6946         shift
6947         realname="$1"
6948         shift
6949
6950         if test -n "$soname_spec"; then
6951           eval soname=\"$soname_spec\"
6952         else
6953           soname="$realname"
6954         fi
6955         if test -z "$dlname"; then
6956           dlname=$soname
6957         fi
6958
6959         lib="$output_objdir/$realname"
6960         linknames=
6961         for link
6962         do
6963           linknames="$linknames $link"
6964         done
6965
6966         # Use standard objects if they are pic
6967         test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
6968         test "X$libobjs" = "X " && libobjs=
6969
6970         delfiles=
6971         if test -n "$export_symbols" && test -n "$include_expsyms"; then
6972           $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
6973           export_symbols="$output_objdir/$libname.uexp"
6974           delfiles="$delfiles $export_symbols"
6975         fi
6976
6977         orig_export_symbols=
6978         case $host_os in
6979         cygwin* | mingw* | cegcc*)
6980           if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
6981             # exporting using user supplied symfile
6982             if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
6983               # and it's NOT already a .def file. Must figure out
6984               # which of the given symbols are data symbols and tag
6985               # them as such. So, trigger use of export_symbols_cmds.
6986               # export_symbols gets reassigned inside the "prepare
6987               # the list of exported symbols" if statement, so the
6988               # include_expsyms logic still works.
6989               orig_export_symbols="$export_symbols"
6990               export_symbols=
6991               always_export_symbols=yes
6992             fi
6993           fi
6994           ;;
6995         esac
6996
6997         # Prepare the list of exported symbols
6998         if test -z "$export_symbols"; then
6999           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
7000             func_verbose "generating symbol list for \`$libname.la'"
7001             export_symbols="$output_objdir/$libname.exp"
7002             $opt_dry_run || $RM $export_symbols
7003             cmds=$export_symbols_cmds
7004             save_ifs="$IFS"; IFS='~'
7005             for cmd in $cmds; do
7006               IFS="$save_ifs"
7007               eval cmd=\"$cmd\"
7008               func_len " $cmd"
7009               len=$func_len_result
7010               if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7011                 func_show_eval "$cmd" 'exit $?'
7012                 skipped_export=false
7013               else
7014                 # The command line is too long to execute in one step.
7015                 func_verbose "using reloadable object file for export list..."
7016                 skipped_export=:
7017                 # Break out early, otherwise skipped_export may be
7018                 # set to false by a later but shorter cmd.
7019                 break
7020               fi
7021             done
7022             IFS="$save_ifs"
7023             if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
7024               func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7025               func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7026             fi
7027           fi
7028         fi
7029
7030         if test -n "$export_symbols" && test -n "$include_expsyms"; then
7031           tmp_export_symbols="$export_symbols"
7032           test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7033           $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7034         fi
7035
7036         if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
7037           # The given exports_symbols file has to be filtered, so filter it.
7038           func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7039           # FIXME: $output_objdir/$libname.filter potentially contains lots of
7040           # 's' commands which not all seds can handle. GNU sed should be fine
7041           # though. Also, the filter scales superlinearly with the number of
7042           # global variables. join(1) would be nice here, but unfortunately
7043           # isn't a blessed tool.
7044           $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7045           delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7046           export_symbols=$output_objdir/$libname.def
7047           $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7048         fi
7049
7050         tmp_deplibs=
7051         for test_deplib in $deplibs; do
7052           case " $convenience " in
7053           *" $test_deplib "*) ;;
7054           *)
7055             tmp_deplibs="$tmp_deplibs $test_deplib"
7056             ;;
7057           esac
7058         done
7059         deplibs="$tmp_deplibs"
7060
7061         if test -n "$convenience"; then
7062           if test -n "$whole_archive_flag_spec" &&
7063             test "$compiler_needs_object" = yes &&
7064             test -z "$libobjs"; then
7065             # extract the archives, so we have objects to list.
7066             # TODO: could optimize this to just extract one archive.
7067             whole_archive_flag_spec=
7068           fi
7069           if test -n "$whole_archive_flag_spec"; then
7070             save_libobjs=$libobjs
7071             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7072             test "X$libobjs" = "X " && libobjs=
7073           else
7074             gentop="$output_objdir/${outputname}x"
7075             generated="$generated $gentop"
7076
7077             func_extract_archives $gentop $convenience
7078             libobjs="$libobjs $func_extract_archives_result"
7079             test "X$libobjs" = "X " && libobjs=
7080           fi
7081         fi
7082
7083         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
7084           eval flag=\"$thread_safe_flag_spec\"
7085           linker_flags="$linker_flags $flag"
7086         fi
7087
7088         # Make a backup of the uninstalled library when relinking
7089         if test "$mode" = relink; then
7090           $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
7091         fi
7092
7093         # Do each of the archive commands.
7094         if test "$module" = yes && test -n "$module_cmds" ; then
7095           if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7096             eval test_cmds=\"$module_expsym_cmds\"
7097             cmds=$module_expsym_cmds
7098           else
7099             eval test_cmds=\"$module_cmds\"
7100             cmds=$module_cmds
7101           fi
7102         else
7103           if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7104             eval test_cmds=\"$archive_expsym_cmds\"
7105             cmds=$archive_expsym_cmds
7106           else
7107             eval test_cmds=\"$archive_cmds\"
7108             cmds=$archive_cmds
7109           fi
7110         fi
7111
7112         if test "X$skipped_export" != "X:" &&
7113            func_len " $test_cmds" &&
7114            len=$func_len_result &&
7115            test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7116           :
7117         else
7118           # The command line is too long to link in one step, link piecewise
7119           # or, if using GNU ld and skipped_export is not :, use a linker
7120           # script.
7121
7122           # Save the value of $output and $libobjs because we want to
7123           # use them later.  If we have whole_archive_flag_spec, we
7124           # want to use save_libobjs as it was before
7125           # whole_archive_flag_spec was expanded, because we can't
7126           # assume the linker understands whole_archive_flag_spec.
7127           # This may have to be revisited, in case too many
7128           # convenience libraries get linked in and end up exceeding
7129           # the spec.
7130           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
7131             save_libobjs=$libobjs
7132           fi
7133           save_output=$output
7134           output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
7135
7136           # Clear the reloadable object creation command queue and
7137           # initialize k to one.
7138           test_cmds=
7139           concat_cmds=
7140           objlist=
7141           last_robj=
7142           k=1
7143
7144           if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
7145             output=${output_objdir}/${output_la}.lnkscript
7146             func_verbose "creating GNU ld script: $output"
7147             $ECHO 'INPUT (' > $output
7148             for obj in $save_libobjs
7149             do
7150               $ECHO "$obj" >> $output
7151             done
7152             $ECHO ')' >> $output
7153             delfiles="$delfiles $output"
7154           elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
7155             output=${output_objdir}/${output_la}.lnk
7156             func_verbose "creating linker input file list: $output"
7157             : > $output
7158             set x $save_libobjs
7159             shift
7160             firstobj=
7161             if test "$compiler_needs_object" = yes; then
7162               firstobj="$1 "
7163               shift
7164             fi
7165             for obj
7166             do
7167               $ECHO "$obj" >> $output
7168             done
7169             delfiles="$delfiles $output"
7170             output=$firstobj\"$file_list_spec$output\"
7171           else
7172             if test -n "$save_libobjs"; then
7173               func_verbose "creating reloadable object files..."
7174               output=$output_objdir/$output_la-${k}.$objext
7175               eval test_cmds=\"$reload_cmds\"
7176               func_len " $test_cmds"
7177               len0=$func_len_result
7178               len=$len0
7179
7180               # Loop over the list of objects to be linked.
7181               for obj in $save_libobjs
7182               do
7183                 func_len " $obj"
7184                 func_arith $len + $func_len_result
7185                 len=$func_arith_result
7186                 if test "X$objlist" = X ||
7187                    test "$len" -lt "$max_cmd_len"; then
7188                   func_append objlist " $obj"
7189                 else
7190                   # The command $test_cmds is almost too long, add a
7191                   # command to the queue.
7192                   if test "$k" -eq 1 ; then
7193                     # The first file doesn't have a previous command to add.
7194                     eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
7195                   else
7196                     # All subsequent reloadable object files will link in
7197                     # the last one created.
7198                     eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"
7199                   fi
7200                   last_robj=$output_objdir/$output_la-${k}.$objext
7201                   func_arith $k + 1
7202                   k=$func_arith_result
7203                   output=$output_objdir/$output_la-${k}.$objext
7204                   objlist=$obj
7205                   func_len " $last_robj"
7206                   func_arith $len0 + $func_len_result
7207                   len=$func_arith_result
7208                 fi
7209               done
7210               # Handle the remaining objects by creating one last
7211               # reloadable object file.  All subsequent reloadable object
7212               # files will link in the last one created.
7213               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7214               eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
7215               if test -n "$last_robj"; then
7216                 eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
7217               fi
7218               delfiles="$delfiles $output"
7219
7220             else
7221               output=
7222             fi
7223
7224             if ${skipped_export-false}; then
7225               func_verbose "generating symbol list for \`$libname.la'"
7226               export_symbols="$output_objdir/$libname.exp"
7227               $opt_dry_run || $RM $export_symbols
7228               libobjs=$output
7229               # Append the command to create the export file.
7230               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7231               eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
7232               if test -n "$last_robj"; then
7233                 eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
7234               fi
7235             fi
7236
7237             test -n "$save_libobjs" &&
7238               func_verbose "creating a temporary reloadable object file: $output"
7239
7240             # Loop through the commands generated above and execute them.
7241             save_ifs="$IFS"; IFS='~'
7242             for cmd in $concat_cmds; do
7243               IFS="$save_ifs"
7244               $opt_silent || {
7245                   func_quote_for_expand "$cmd"
7246                   eval "func_echo $func_quote_for_expand_result"
7247               }
7248               $opt_dry_run || eval "$cmd" || {
7249                 lt_exit=$?
7250
7251                 # Restore the uninstalled library and exit
7252                 if test "$mode" = relink; then
7253                   ( cd "$output_objdir" && \
7254                     $RM "${realname}T" && \
7255                     $MV "${realname}U" "$realname" )
7256                 fi
7257
7258                 exit $lt_exit
7259               }
7260             done
7261             IFS="$save_ifs"
7262
7263             if test -n "$export_symbols_regex" && ${skipped_export-false}; then
7264               func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7265               func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7266             fi
7267           fi
7268
7269           if ${skipped_export-false}; then
7270             if test -n "$export_symbols" && test -n "$include_expsyms"; then
7271               tmp_export_symbols="$export_symbols"
7272               test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7273               $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7274             fi
7275
7276             if test -n "$orig_export_symbols"; then
7277               # The given exports_symbols file has to be filtered, so filter it.
7278               func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7279               # FIXME: $output_objdir/$libname.filter potentially contains lots of
7280               # 's' commands which not all seds can handle. GNU sed should be fine
7281               # though. Also, the filter scales superlinearly with the number of
7282               # global variables. join(1) would be nice here, but unfortunately
7283               # isn't a blessed tool.
7284               $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7285               delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7286               export_symbols=$output_objdir/$libname.def
7287               $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7288             fi
7289           fi
7290
7291           libobjs=$output
7292           # Restore the value of output.
7293           output=$save_output
7294
7295           if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
7296             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7297             test "X$libobjs" = "X " && libobjs=
7298           fi
7299           # Expand the library linking commands again to reset the
7300           # value of $libobjs for piecewise linking.
7301
7302           # Do each of the archive commands.
7303           if test "$module" = yes && test -n "$module_cmds" ; then
7304             if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7305               cmds=$module_expsym_cmds
7306             else
7307               cmds=$module_cmds
7308             fi
7309           else
7310             if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7311               cmds=$archive_expsym_cmds
7312             else
7313               cmds=$archive_cmds
7314             fi
7315           fi
7316         fi
7317
7318         if test -n "$delfiles"; then
7319           # Append the command to remove temporary files to $cmds.
7320           eval cmds=\"\$cmds~\$RM $delfiles\"
7321         fi
7322
7323         # Add any objects from preloaded convenience libraries
7324         if test -n "$dlprefiles"; then
7325           gentop="$output_objdir/${outputname}x"
7326           generated="$generated $gentop"
7327
7328           func_extract_archives $gentop $dlprefiles
7329           libobjs="$libobjs $func_extract_archives_result"
7330           test "X$libobjs" = "X " && libobjs=
7331         fi
7332
7333         save_ifs="$IFS"; IFS='~'
7334         for cmd in $cmds; do
7335           IFS="$save_ifs"
7336           eval cmd=\"$cmd\"
7337           $opt_silent || {
7338             func_quote_for_expand "$cmd"
7339             eval "func_echo $func_quote_for_expand_result"
7340           }
7341           $opt_dry_run || eval "$cmd" || {
7342             lt_exit=$?
7343
7344             # Restore the uninstalled library and exit
7345             if test "$mode" = relink; then
7346               ( cd "$output_objdir" && \
7347                 $RM "${realname}T" && \
7348                 $MV "${realname}U" "$realname" )
7349             fi
7350
7351             exit $lt_exit
7352           }
7353         done
7354         IFS="$save_ifs"
7355
7356         # Restore the uninstalled library and exit
7357         if test "$mode" = relink; then
7358           $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
7359
7360           if test -n "$convenience"; then
7361             if test -z "$whole_archive_flag_spec"; then
7362               func_show_eval '${RM}r "$gentop"'
7363             fi
7364           fi
7365
7366           exit $EXIT_SUCCESS
7367         fi
7368
7369         # Create links to the real library.
7370         for linkname in $linknames; do
7371           if test "$realname" != "$linkname"; then
7372             func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
7373           fi
7374         done
7375
7376         # If -module or -export-dynamic was specified, set the dlname.
7377         if test "$module" = yes || test "$export_dynamic" = yes; then
7378           # On all known operating systems, these are identical.
7379           dlname="$soname"
7380         fi
7381       fi
7382       ;;
7383
7384     obj)
7385       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7386         func_warning "\`-dlopen' is ignored for objects"
7387       fi
7388
7389       case " $deplibs" in
7390       *\ -l* | *\ -L*)
7391         func_warning "\`-l' and \`-L' are ignored for objects" ;;
7392       esac
7393
7394       test -n "$rpath" && \
7395         func_warning "\`-rpath' is ignored for objects"
7396
7397       test -n "$xrpath" && \
7398         func_warning "\`-R' is ignored for objects"
7399
7400       test -n "$vinfo" && \
7401         func_warning "\`-version-info' is ignored for objects"
7402
7403       test -n "$release" && \
7404         func_warning "\`-release' is ignored for objects"
7405
7406       case $output in
7407       *.lo)
7408         test -n "$objs$old_deplibs" && \
7409           func_fatal_error "cannot build library object \`$output' from non-libtool objects"
7410
7411         libobj=$output
7412         func_lo2o "$libobj"
7413         obj=$func_lo2o_result
7414         ;;
7415       *)
7416         libobj=
7417         obj="$output"
7418         ;;
7419       esac
7420
7421       # Delete the old objects.
7422       $opt_dry_run || $RM $obj $libobj
7423
7424       # Objects from convenience libraries.  This assumes
7425       # single-version convenience libraries.  Whenever we create
7426       # different ones for PIC/non-PIC, this we'll have to duplicate
7427       # the extraction.
7428       reload_conv_objs=
7429       gentop=
7430       # reload_cmds runs $LD directly, so let us get rid of
7431       # -Wl from whole_archive_flag_spec and hope we can get by with
7432       # turning comma into space..
7433       wl=
7434
7435       if test -n "$convenience"; then
7436         if test -n "$whole_archive_flag_spec"; then
7437           eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
7438           reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
7439         else
7440           gentop="$output_objdir/${obj}x"
7441           generated="$generated $gentop"
7442
7443           func_extract_archives $gentop $convenience
7444           reload_conv_objs="$reload_objs $func_extract_archives_result"
7445         fi
7446       fi
7447
7448       # Create the old-style object.
7449       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
7450
7451       output="$obj"
7452       func_execute_cmds "$reload_cmds" 'exit $?'
7453
7454       # Exit if we aren't doing a library object file.
7455       if test -z "$libobj"; then
7456         if test -n "$gentop"; then
7457           func_show_eval '${RM}r "$gentop"'
7458         fi
7459
7460         exit $EXIT_SUCCESS
7461       fi
7462
7463       if test "$build_libtool_libs" != yes; then
7464         if test -n "$gentop"; then
7465           func_show_eval '${RM}r "$gentop"'
7466         fi
7467
7468         # Create an invalid libtool object if no PIC, so that we don't
7469         # accidentally link it into a program.
7470         # $show "echo timestamp > $libobj"
7471         # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
7472         exit $EXIT_SUCCESS
7473       fi
7474
7475       if test -n "$pic_flag" || test "$pic_mode" != default; then
7476         # Only do commands if we really have different PIC objects.
7477         reload_objs="$libobjs $reload_conv_objs"
7478         output="$libobj"
7479         func_execute_cmds "$reload_cmds" 'exit $?'
7480       fi
7481
7482       if test -n "$gentop"; then
7483         func_show_eval '${RM}r "$gentop"'
7484       fi
7485
7486       exit $EXIT_SUCCESS
7487       ;;
7488
7489     prog)
7490       case $host in
7491         *cygwin*) func_stripname '' '.exe' "$output"
7492                   output=$func_stripname_result.exe;;
7493       esac
7494       test -n "$vinfo" && \
7495         func_warning "\`-version-info' is ignored for programs"
7496
7497       test -n "$release" && \
7498         func_warning "\`-release' is ignored for programs"
7499
7500       test "$preload" = yes \
7501         && test "$dlopen_support" = unknown \
7502         && test "$dlopen_self" = unknown \
7503         && test "$dlopen_self_static" = unknown && \
7504           func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
7505
7506       case $host in
7507       *-*-rhapsody* | *-*-darwin1.[012])
7508         # On Rhapsody replace the C library is the System framework
7509         compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7510         finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7511         ;;
7512       esac
7513
7514       case $host in
7515       *-*-darwin*)
7516         # Don't allow lazy linking, it breaks C++ global constructors
7517         # But is supposedly fixed on 10.4 or later (yay!).
7518         if test "$tagname" = CXX ; then
7519           case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
7520             10.[0123])
7521               compile_command="$compile_command ${wl}-bind_at_load"
7522               finalize_command="$finalize_command ${wl}-bind_at_load"
7523             ;;
7524           esac
7525         fi
7526         # Time to change all our "foo.ltframework" stuff back to "-framework foo"
7527         compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7528         finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7529         ;;
7530       esac
7531
7532
7533       # move library search paths that coincide with paths to not yet
7534       # installed libraries to the beginning of the library search list
7535       new_libs=
7536       for path in $notinst_path; do
7537         case " $new_libs " in
7538         *" -L$path/$objdir "*) ;;
7539         *)
7540           case " $compile_deplibs " in
7541           *" -L$path/$objdir "*)
7542             new_libs="$new_libs -L$path/$objdir" ;;
7543           esac
7544           ;;
7545         esac
7546       done
7547       for deplib in $compile_deplibs; do
7548         case $deplib in
7549         -L*)
7550           case " $new_libs " in
7551           *" $deplib "*) ;;
7552           *) new_libs="$new_libs $deplib" ;;
7553           esac
7554           ;;
7555         *) new_libs="$new_libs $deplib" ;;
7556         esac
7557       done
7558       compile_deplibs="$new_libs"
7559
7560
7561       compile_command="$compile_command $compile_deplibs"
7562       finalize_command="$finalize_command $finalize_deplibs"
7563
7564       if test -n "$rpath$xrpath"; then
7565         # If the user specified any rpath flags, then add them.
7566         for libdir in $rpath $xrpath; do
7567           # This is the magic to use -rpath.
7568           case "$finalize_rpath " in
7569           *" $libdir "*) ;;
7570           *) finalize_rpath="$finalize_rpath $libdir" ;;
7571           esac
7572         done
7573       fi
7574
7575       # Now hardcode the library paths
7576       rpath=
7577       hardcode_libdirs=
7578       for libdir in $compile_rpath $finalize_rpath; do
7579         if test -n "$hardcode_libdir_flag_spec"; then
7580           if test -n "$hardcode_libdir_separator"; then
7581             if test -z "$hardcode_libdirs"; then
7582               hardcode_libdirs="$libdir"
7583             else
7584               # Just accumulate the unique libdirs.
7585               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7586               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7587                 ;;
7588               *)
7589                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7590                 ;;
7591               esac
7592             fi
7593           else
7594             eval flag=\"$hardcode_libdir_flag_spec\"
7595             rpath="$rpath $flag"
7596           fi
7597         elif test -n "$runpath_var"; then
7598           case "$perm_rpath " in
7599           *" $libdir "*) ;;
7600           *) perm_rpath="$perm_rpath $libdir" ;;
7601           esac
7602         fi
7603         case $host in
7604         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
7605           testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
7606           case :$dllsearchpath: in
7607           *":$libdir:"*) ;;
7608           ::) dllsearchpath=$libdir;;
7609           *) dllsearchpath="$dllsearchpath:$libdir";;
7610           esac
7611           case :$dllsearchpath: in
7612           *":$testbindir:"*) ;;
7613           ::) dllsearchpath=$testbindir;;
7614           *) dllsearchpath="$dllsearchpath:$testbindir";;
7615           esac
7616           ;;
7617         esac
7618       done
7619       # Substitute the hardcoded libdirs into the rpath.
7620       if test -n "$hardcode_libdir_separator" &&
7621          test -n "$hardcode_libdirs"; then
7622         libdir="$hardcode_libdirs"
7623         eval rpath=\" $hardcode_libdir_flag_spec\"
7624       fi
7625       compile_rpath="$rpath"
7626
7627       rpath=
7628       hardcode_libdirs=
7629       for libdir in $finalize_rpath; do
7630         if test -n "$hardcode_libdir_flag_spec"; then
7631           if test -n "$hardcode_libdir_separator"; then
7632             if test -z "$hardcode_libdirs"; then
7633               hardcode_libdirs="$libdir"
7634             else
7635               # Just accumulate the unique libdirs.
7636               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7637               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7638                 ;;
7639               *)
7640                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7641                 ;;
7642               esac
7643             fi
7644           else
7645             eval flag=\"$hardcode_libdir_flag_spec\"
7646             rpath="$rpath $flag"
7647           fi
7648         elif test -n "$runpath_var"; then
7649           case "$finalize_perm_rpath " in
7650           *" $libdir "*) ;;
7651           *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
7652           esac
7653         fi
7654       done
7655       # Substitute the hardcoded libdirs into the rpath.
7656       if test -n "$hardcode_libdir_separator" &&
7657          test -n "$hardcode_libdirs"; then
7658         libdir="$hardcode_libdirs"
7659         eval rpath=\" $hardcode_libdir_flag_spec\"
7660       fi
7661       finalize_rpath="$rpath"
7662
7663       if test -n "$libobjs" && test "$build_old_libs" = yes; then
7664         # Transform all the library objects into standard objects.
7665         compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7666         finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7667       fi
7668
7669       func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
7670
7671       # template prelinking step
7672       if test -n "$prelink_cmds"; then
7673         func_execute_cmds "$prelink_cmds" 'exit $?'
7674       fi
7675
7676       wrappers_required=yes
7677       case $host in
7678       *cygwin* | *mingw* )
7679         if test "$build_libtool_libs" != yes; then
7680           wrappers_required=no
7681         fi
7682         ;;
7683       *cegcc)
7684         # Disable wrappers for cegcc, we are cross compiling anyway.
7685         wrappers_required=no
7686         ;;
7687       *)
7688         if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
7689           wrappers_required=no
7690         fi
7691         ;;
7692       esac
7693       if test "$wrappers_required" = no; then
7694         # Replace the output file specification.
7695         compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
7696         link_command="$compile_command$compile_rpath"
7697
7698         # We have no uninstalled library dependencies, so finalize right now.
7699         exit_status=0
7700         func_show_eval "$link_command" 'exit_status=$?'
7701
7702         # Delete the generated files.
7703         if test -f "$output_objdir/${outputname}S.${objext}"; then
7704           func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
7705         fi
7706
7707         exit $exit_status
7708       fi
7709
7710       if test -n "$compile_shlibpath$finalize_shlibpath"; then
7711         compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
7712       fi
7713       if test -n "$finalize_shlibpath"; then
7714         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
7715       fi
7716
7717       compile_var=
7718       finalize_var=
7719       if test -n "$runpath_var"; then
7720         if test -n "$perm_rpath"; then
7721           # We should set the runpath_var.
7722           rpath=
7723           for dir in $perm_rpath; do
7724             rpath="$rpath$dir:"
7725           done
7726           compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
7727         fi
7728         if test -n "$finalize_perm_rpath"; then
7729           # We should set the runpath_var.
7730           rpath=
7731           for dir in $finalize_perm_rpath; do
7732             rpath="$rpath$dir:"
7733           done
7734           finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
7735         fi
7736       fi
7737
7738       if test "$no_install" = yes; then
7739         # We don't need to create a wrapper script.
7740         link_command="$compile_var$compile_command$compile_rpath"
7741         # Replace the output file specification.
7742         link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
7743         # Delete the old output file.
7744         $opt_dry_run || $RM $output
7745         # Link the executable and exit
7746         func_show_eval "$link_command" 'exit $?'
7747         exit $EXIT_SUCCESS
7748       fi
7749
7750       if test "$hardcode_action" = relink; then
7751         # Fast installation is not supported
7752         link_command="$compile_var$compile_command$compile_rpath"
7753         relink_command="$finalize_var$finalize_command$finalize_rpath"
7754
7755         func_warning "this platform does not like uninstalled shared libraries"
7756         func_warning "\`$output' will be relinked during installation"
7757       else
7758         if test "$fast_install" != no; then
7759           link_command="$finalize_var$compile_command$finalize_rpath"
7760           if test "$fast_install" = yes; then
7761             relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
7762           else
7763             # fast_install is set to needless
7764             relink_command=
7765           fi
7766         else
7767           link_command="$compile_var$compile_command$compile_rpath"
7768           relink_command="$finalize_var$finalize_command$finalize_rpath"
7769         fi
7770       fi
7771
7772       # Replace the output file specification.
7773       link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7774
7775       # Delete the old output files.
7776       $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
7777
7778       func_show_eval "$link_command" 'exit $?'
7779
7780       # Now create the wrapper script.
7781       func_verbose "creating $output"
7782
7783       # Quote the relink command for shipping.
7784       if test -n "$relink_command"; then
7785         # Preserve any variables that may affect compiler behavior
7786         for var in $variables_saved_for_relink; do
7787           if eval test -z \"\${$var+set}\"; then
7788             relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
7789           elif eval var_value=\$$var; test -z "$var_value"; then
7790             relink_command="$var=; export $var; $relink_command"
7791           else
7792             func_quote_for_eval "$var_value"
7793             relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
7794           fi
7795         done
7796         relink_command="(cd `pwd`; $relink_command)"
7797         relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
7798       fi
7799
7800       # Quote $ECHO for shipping.
7801       if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
7802         case $progpath in
7803         [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
7804         *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
7805         esac
7806         qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
7807       else
7808         qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
7809       fi
7810
7811       # Only actually do things if not in dry run mode.
7812       $opt_dry_run || {
7813         # win32 will think the script is a binary if it has
7814         # a .exe suffix, so we strip it off here.
7815         case $output in
7816           *.exe) func_stripname '' '.exe' "$output"
7817                  output=$func_stripname_result ;;
7818         esac
7819         # test for cygwin because mv fails w/o .exe extensions
7820         case $host in
7821           *cygwin*)
7822             exeext=.exe
7823             func_stripname '' '.exe' "$outputname"
7824             outputname=$func_stripname_result ;;
7825           *) exeext= ;;
7826         esac
7827         case $host in
7828           *cygwin* | *mingw* )
7829             func_dirname_and_basename "$output" "" "."
7830             output_name=$func_basename_result
7831             output_path=$func_dirname_result
7832             cwrappersource="$output_path/$objdir/lt-$output_name.c"
7833             cwrapper="$output_path/$output_name.exe"
7834             $RM $cwrappersource $cwrapper
7835             trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
7836
7837             func_emit_cwrapperexe_src > $cwrappersource
7838
7839             # The wrapper executable is built using the $host compiler,
7840             # because it contains $host paths and files. If cross-
7841             # compiling, it, like the target executable, must be
7842             # executed on the $host or under an emulation environment.
7843             $opt_dry_run || {
7844               $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
7845               $STRIP $cwrapper
7846             }
7847
7848             # Now, create the wrapper script for func_source use:
7849             func_ltwrapper_scriptname $cwrapper
7850             $RM $func_ltwrapper_scriptname_result
7851             trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
7852             $opt_dry_run || {
7853               # note: this script will not be executed, so do not chmod.
7854               if test "x$build" = "x$host" ; then
7855                 $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
7856               else
7857                 func_emit_wrapper no > $func_ltwrapper_scriptname_result
7858               fi
7859             }
7860           ;;
7861           * )
7862             $RM $output
7863             trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
7864
7865             func_emit_wrapper no > $output
7866             chmod +x $output
7867           ;;
7868         esac
7869       }
7870       exit $EXIT_SUCCESS
7871       ;;
7872     esac
7873
7874     # See if we need to build an old-fashioned archive.
7875     for oldlib in $oldlibs; do
7876
7877       if test "$build_libtool_libs" = convenience; then
7878         oldobjs="$libobjs_save $symfileobj"
7879         addlibs="$convenience"
7880         build_libtool_libs=no
7881       else
7882         if test "$build_libtool_libs" = module; then
7883           oldobjs="$libobjs_save"
7884           build_libtool_libs=no
7885         else
7886           oldobjs="$old_deplibs $non_pic_objects"
7887           if test "$preload" = yes && test -f "$symfileobj"; then
7888             oldobjs="$oldobjs $symfileobj"
7889           fi
7890         fi
7891         addlibs="$old_convenience"
7892       fi
7893
7894       if test -n "$addlibs"; then
7895         gentop="$output_objdir/${outputname}x"
7896         generated="$generated $gentop"
7897
7898         func_extract_archives $gentop $addlibs
7899         oldobjs="$oldobjs $func_extract_archives_result"
7900       fi
7901
7902       # Do each command in the archive commands.
7903       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
7904         cmds=$old_archive_from_new_cmds
7905       else
7906
7907         # Add any objects from preloaded convenience libraries
7908         if test -n "$dlprefiles"; then
7909           gentop="$output_objdir/${outputname}x"
7910           generated="$generated $gentop"
7911
7912           func_extract_archives $gentop $dlprefiles
7913           oldobjs="$oldobjs $func_extract_archives_result"
7914         fi
7915
7916         # POSIX demands no paths to be encoded in archives.  We have
7917         # to avoid creating archives with duplicate basenames if we
7918         # might have to extract them afterwards, e.g., when creating a
7919         # static archive out of a convenience library, or when linking
7920         # the entirety of a libtool archive into another (currently
7921         # not supported by libtool).
7922         if (for obj in $oldobjs
7923             do
7924               func_basename "$obj"
7925               $ECHO "$func_basename_result"
7926             done | sort | sort -uc >/dev/null 2>&1); then
7927           :
7928         else
7929           $ECHO "copying selected object files to avoid basename conflicts..."
7930           gentop="$output_objdir/${outputname}x"
7931           generated="$generated $gentop"
7932           func_mkdir_p "$gentop"
7933           save_oldobjs=$oldobjs
7934           oldobjs=
7935           counter=1
7936           for obj in $save_oldobjs
7937           do
7938             func_basename "$obj"
7939             objbase="$func_basename_result"
7940             case " $oldobjs " in
7941             " ") oldobjs=$obj ;;
7942             *[\ /]"$objbase "*)
7943               while :; do
7944                 # Make sure we don't pick an alternate name that also
7945                 # overlaps.
7946                 newobj=lt$counter-$objbase
7947                 func_arith $counter + 1
7948                 counter=$func_arith_result
7949                 case " $oldobjs " in
7950                 *[\ /]"$newobj "*) ;;
7951                 *) if test ! -f "$gentop/$newobj"; then break; fi ;;
7952                 esac
7953               done
7954               func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
7955               oldobjs="$oldobjs $gentop/$newobj"
7956               ;;
7957             *) oldobjs="$oldobjs $obj" ;;
7958             esac
7959           done
7960         fi
7961         eval cmds=\"$old_archive_cmds\"
7962
7963         func_len " $cmds"
7964         len=$func_len_result
7965         if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7966           cmds=$old_archive_cmds
7967         else
7968           # the command line is too long to link in one step, link in parts
7969           func_verbose "using piecewise archive linking..."
7970           save_RANLIB=$RANLIB
7971           RANLIB=:
7972           objlist=
7973           concat_cmds=
7974           save_oldobjs=$oldobjs
7975           oldobjs=
7976           # Is there a better way of finding the last object in the list?
7977           for obj in $save_oldobjs
7978           do
7979             last_oldobj=$obj
7980           done
7981           eval test_cmds=\"$old_archive_cmds\"
7982           func_len " $test_cmds"
7983           len0=$func_len_result
7984           len=$len0
7985           for obj in $save_oldobjs
7986           do
7987             func_len " $obj"
7988             func_arith $len + $func_len_result
7989             len=$func_arith_result
7990             func_append objlist " $obj"
7991             if test "$len" -lt "$max_cmd_len"; then
7992               :
7993             else
7994               # the above command should be used before it gets too long
7995               oldobjs=$objlist
7996               if test "$obj" = "$last_oldobj" ; then
7997                 RANLIB=$save_RANLIB
7998               fi
7999               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8000               eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
8001               objlist=
8002               len=$len0
8003             fi
8004           done
8005           RANLIB=$save_RANLIB
8006           oldobjs=$objlist
8007           if test "X$oldobjs" = "X" ; then
8008             eval cmds=\"\$concat_cmds\"
8009           else
8010             eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
8011           fi
8012         fi
8013       fi
8014       func_execute_cmds "$cmds" 'exit $?'
8015     done
8016
8017     test -n "$generated" && \
8018       func_show_eval "${RM}r$generated"
8019
8020     # Now create the libtool archive.
8021     case $output in
8022     *.la)
8023       old_library=
8024       test "$build_old_libs" = yes && old_library="$libname.$libext"
8025       func_verbose "creating $output"
8026
8027       # Preserve any variables that may affect compiler behavior
8028       for var in $variables_saved_for_relink; do
8029         if eval test -z \"\${$var+set}\"; then
8030           relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8031         elif eval var_value=\$$var; test -z "$var_value"; then
8032           relink_command="$var=; export $var; $relink_command"
8033         else
8034           func_quote_for_eval "$var_value"
8035           relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8036         fi
8037       done
8038       # Quote the link command for shipping.
8039       relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
8040       relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
8041       if test "$hardcode_automatic" = yes ; then
8042         relink_command=
8043       fi
8044
8045       # Only create the output if not a dry run.
8046       $opt_dry_run || {
8047         for installed in no yes; do
8048           if test "$installed" = yes; then
8049             if test -z "$install_libdir"; then
8050               break
8051             fi
8052             output="$output_objdir/$outputname"i
8053             # Replace all uninstalled libtool libraries with the installed ones
8054             newdependency_libs=
8055             for deplib in $dependency_libs; do
8056               case $deplib in
8057               *.la)
8058                 func_basename "$deplib"
8059                 name="$func_basename_result"
8060                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
8061                 test -z "$libdir" && \
8062                   func_fatal_error "\`$deplib' is not a valid libtool archive"
8063                 newdependency_libs="$newdependency_libs $libdir/$name"
8064                 ;;
8065               *) newdependency_libs="$newdependency_libs $deplib" ;;
8066               esac
8067             done
8068             dependency_libs="$newdependency_libs"
8069             newdlfiles=
8070
8071             for lib in $dlfiles; do
8072               case $lib in
8073               *.la)
8074                 func_basename "$lib"
8075                 name="$func_basename_result"
8076                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8077                 test -z "$libdir" && \
8078                   func_fatal_error "\`$lib' is not a valid libtool archive"
8079                 newdlfiles="$newdlfiles $libdir/$name"
8080                 ;;
8081               *) newdlfiles="$newdlfiles $lib" ;;
8082               esac
8083             done
8084             dlfiles="$newdlfiles"
8085             newdlprefiles=
8086             for lib in $dlprefiles; do
8087               case $lib in
8088               *.la)
8089                 # Only pass preopened files to the pseudo-archive (for
8090                 # eventual linking with the app. that links it) if we
8091                 # didn't already link the preopened objects directly into
8092                 # the library:
8093                 func_basename "$lib"
8094                 name="$func_basename_result"
8095                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8096                 test -z "$libdir" && \
8097                   func_fatal_error "\`$lib' is not a valid libtool archive"
8098                 newdlprefiles="$newdlprefiles $libdir/$name"
8099                 ;;
8100               esac
8101             done
8102             dlprefiles="$newdlprefiles"
8103           else
8104             newdlfiles=
8105             for lib in $dlfiles; do
8106               case $lib in
8107                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8108                 *) abs=`pwd`"/$lib" ;;
8109               esac
8110               newdlfiles="$newdlfiles $abs"
8111             done
8112             dlfiles="$newdlfiles"
8113             newdlprefiles=
8114             for lib in $dlprefiles; do
8115               case $lib in
8116                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8117                 *) abs=`pwd`"/$lib" ;;
8118               esac
8119               newdlprefiles="$newdlprefiles $abs"
8120             done
8121             dlprefiles="$newdlprefiles"
8122           fi
8123           $RM $output
8124           # place dlname in correct position for cygwin
8125           tdlname=$dlname
8126           case $host,$output,$installed,$module,$dlname in
8127             *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
8128           esac
8129           $ECHO > $output "\
8130 # $outputname - a libtool library file
8131 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
8132 #
8133 # Please DO NOT delete this file!
8134 # It is necessary for linking the library.
8135
8136 # The name that we can dlopen(3).
8137 dlname='$tdlname'
8138
8139 # Names of this library.
8140 library_names='$library_names'
8141
8142 # The name of the static archive.
8143 old_library='$old_library'
8144
8145 # Linker flags that can not go in dependency_libs.
8146 inherited_linker_flags='$new_inherited_linker_flags'
8147
8148 # Libraries that this one depends upon.
8149 dependency_libs='$dependency_libs'
8150
8151 # Names of additional weak libraries provided by this library
8152 weak_library_names='$weak_libs'
8153
8154 # Version information for $libname.
8155 current=$current
8156 age=$age
8157 revision=$revision
8158
8159 # Is this an already installed library?
8160 installed=$installed
8161
8162 # Should we warn about portability when linking against -modules?
8163 shouldnotlink=$module
8164
8165 # Files to dlopen/dlpreopen
8166 dlopen='$dlfiles'
8167 dlpreopen='$dlprefiles'
8168
8169 # Directory that this library needs to be installed in:
8170 libdir='$install_libdir'"
8171           if test "$installed" = no && test "$need_relink" = yes; then
8172             $ECHO >> $output "\
8173 relink_command=\"$relink_command\""
8174           fi
8175         done
8176       }
8177
8178       # Do a symbolic link so that the libtool archive can be found in
8179       # LD_LIBRARY_PATH before the program is installed.
8180       func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
8181       ;;
8182     esac
8183     exit $EXIT_SUCCESS
8184 }
8185
8186 { test "$mode" = link || test "$mode" = relink; } &&
8187     func_mode_link ${1+"$@"}
8188
8189
8190 # func_mode_uninstall arg...
8191 func_mode_uninstall ()
8192 {
8193     $opt_debug
8194     RM="$nonopt"
8195     files=
8196     rmforce=
8197     exit_status=0
8198
8199     # This variable tells wrapper scripts just to set variables rather
8200     # than running their programs.
8201     libtool_install_magic="$magic"
8202
8203     for arg
8204     do
8205       case $arg in
8206       -f) RM="$RM $arg"; rmforce=yes ;;
8207       -*) RM="$RM $arg" ;;
8208       *) files="$files $arg" ;;
8209       esac
8210     done
8211
8212     test -z "$RM" && \
8213       func_fatal_help "you must specify an RM program"
8214
8215     rmdirs=
8216
8217     origobjdir="$objdir"
8218     for file in $files; do
8219       func_dirname "$file" "" "."
8220       dir="$func_dirname_result"
8221       if test "X$dir" = X.; then
8222         objdir="$origobjdir"
8223       else
8224         objdir="$dir/$origobjdir"
8225       fi
8226       func_basename "$file"
8227       name="$func_basename_result"
8228       test "$mode" = uninstall && objdir="$dir"
8229
8230       # Remember objdir for removal later, being careful to avoid duplicates
8231       if test "$mode" = clean; then
8232         case " $rmdirs " in
8233           *" $objdir "*) ;;
8234           *) rmdirs="$rmdirs $objdir" ;;
8235         esac
8236       fi
8237
8238       # Don't error if the file doesn't exist and rm -f was used.
8239       if { test -L "$file"; } >/dev/null 2>&1 ||
8240          { test -h "$file"; } >/dev/null 2>&1 ||
8241          test -f "$file"; then
8242         :
8243       elif test -d "$file"; then
8244         exit_status=1
8245         continue
8246       elif test "$rmforce" = yes; then
8247         continue
8248       fi
8249
8250       rmfiles="$file"
8251
8252       case $name in
8253       *.la)
8254         # Possibly a libtool archive, so verify it.
8255         if func_lalib_p "$file"; then
8256           func_source $dir/$name
8257
8258           # Delete the libtool libraries and symlinks.
8259           for n in $library_names; do
8260             rmfiles="$rmfiles $objdir/$n"
8261           done
8262           test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
8263
8264           case "$mode" in
8265           clean)
8266             case "  $library_names " in
8267             # "  " in the beginning catches empty $dlname
8268             *" $dlname "*) ;;
8269             *) rmfiles="$rmfiles $objdir/$dlname" ;;
8270             esac
8271             test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
8272             ;;
8273           uninstall)
8274             if test -n "$library_names"; then
8275               # Do each command in the postuninstall commands.
8276               func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8277             fi
8278
8279             if test -n "$old_library"; then
8280               # Do each command in the old_postuninstall commands.
8281               func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8282             fi
8283             # FIXME: should reinstall the best remaining shared library.
8284             ;;
8285           esac
8286         fi
8287         ;;
8288
8289       *.lo)
8290         # Possibly a libtool object, so verify it.
8291         if func_lalib_p "$file"; then
8292
8293           # Read the .lo file
8294           func_source $dir/$name
8295
8296           # Add PIC object to the list of files to remove.
8297           if test -n "$pic_object" &&
8298              test "$pic_object" != none; then
8299             rmfiles="$rmfiles $dir/$pic_object"
8300           fi
8301
8302           # Add non-PIC object to the list of files to remove.
8303           if test -n "$non_pic_object" &&
8304              test "$non_pic_object" != none; then
8305             rmfiles="$rmfiles $dir/$non_pic_object"
8306           fi
8307         fi
8308         ;;
8309
8310       *)
8311         if test "$mode" = clean ; then
8312           noexename=$name
8313           case $file in
8314           *.exe)
8315             func_stripname '' '.exe' "$file"
8316             file=$func_stripname_result
8317             func_stripname '' '.exe' "$name"
8318             noexename=$func_stripname_result
8319             # $file with .exe has already been added to rmfiles,
8320             # add $file without .exe
8321             rmfiles="$rmfiles $file"
8322             ;;
8323           esac
8324           # Do a test to see if this is a libtool program.
8325           if func_ltwrapper_p "$file"; then
8326             if func_ltwrapper_executable_p "$file"; then
8327               func_ltwrapper_scriptname "$file"
8328               relink_command=
8329               func_source $func_ltwrapper_scriptname_result
8330               rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
8331             else
8332               relink_command=
8333               func_source $dir/$noexename
8334             fi
8335
8336             # note $name still contains .exe if it was in $file originally
8337             # as does the version of $file that was added into $rmfiles
8338             rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
8339             if test "$fast_install" = yes && test -n "$relink_command"; then
8340               rmfiles="$rmfiles $objdir/lt-$name"
8341             fi
8342             if test "X$noexename" != "X$name" ; then
8343               rmfiles="$rmfiles $objdir/lt-${noexename}.c"
8344             fi
8345           fi
8346         fi
8347         ;;
8348       esac
8349       func_show_eval "$RM $rmfiles" 'exit_status=1'
8350     done
8351     objdir="$origobjdir"
8352
8353     # Try to remove the ${objdir}s in the directories where we deleted files
8354     for dir in $rmdirs; do
8355       if test -d "$dir"; then
8356         func_show_eval "rmdir $dir >/dev/null 2>&1"
8357       fi
8358     done
8359
8360     exit $exit_status
8361 }
8362
8363 { test "$mode" = uninstall || test "$mode" = clean; } &&
8364     func_mode_uninstall ${1+"$@"}
8365
8366 test -z "$mode" && {
8367   help="$generic_help"
8368   func_fatal_help "you must specify a MODE"
8369 }
8370
8371 test -z "$exec_cmd" && \
8372   func_fatal_help "invalid operation mode \`$mode'"
8373
8374 if test -n "$exec_cmd"; then
8375   eval exec "$exec_cmd"
8376   exit $EXIT_FAILURE
8377 fi
8378
8379 exit $exit_status
8380
8381
8382 # The TAGs below are defined such that we never get into a situation
8383 # in which we disable both kinds of libraries.  Given conflicting
8384 # choices, we go for a static library, that is the most portable,
8385 # since we can't tell whether shared libraries were disabled because
8386 # the user asked for that or because the platform doesn't support
8387 # them.  This is particularly important on AIX, because we don't
8388 # support having both static and shared libraries enabled at the same
8389 # time on that platform, so we default to a shared-only configuration.
8390 # If a disable-shared tag is given, we'll fallback to a static-only
8391 # configuration.  But we'll never go from static-only to shared-only.
8392
8393 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
8394 build_libtool_libs=no
8395 build_old_libs=yes
8396 # ### END LIBTOOL TAG CONFIG: disable-shared
8397
8398 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
8399 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
8400 # ### END LIBTOOL TAG CONFIG: disable-static
8401
8402 # Local Variables:
8403 # mode:shell-script
8404 # sh-indentation:2
8405 # End:
8406 # vi:sw=2
8407