config/ltmain.sh

   1 #! /bin/sh
   2 # Generated from ltmain.m4sh.
   3
   4 # ltmain.sh (GNU libtool) 2.2.6b
   5 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
   6
   7 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc.
   8 # This is free software; see the source for copying conditions.  There is NO
   9 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  10
  11 # GNU Libtool is free software; you can redistribute it and/or modify
  12 # it under the terms of the GNU General Public License as published by
  13 # the Free Software Foundation; either version 2 of the License, or
  14 # (at your option) any later version.
  15 #
  16 # As a special exception to the GNU General Public License,
  17 # if you distribute this file as part of a program or library that
  18 # is built using GNU Libtool, you may include this file under the
  19 # same distribution terms that you use for the rest of that program.
  20 #
  21 # GNU Libtool is distributed in the hope that it will be useful, but
  22 # WITHOUT ANY WARRANTY; without even the implied warranty of
  23 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24 # General Public License for more details.
  25 #
  26 # You should have received a copy of the GNU General Public License
  27 # along with GNU Libtool; see the file COPYING.  If not, a copy
  28 # can be downloaded from http://www.gnu.org/licenses/gpl.html,
  29 # or obtained by writing to the Free Software Foundation, Inc.,
  30 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  31
  32 # Usage: $progname [OPTION]... [MODE-ARG]...
  33 #
  34 # Provide generalized library-building support services.
  35 #
  36 #     --config             show all configuration variables
  37 #     --debug              enable verbose shell tracing
  38 # -n, --dry-run            display commands without modifying any files
  39 #     --features           display basic configuration information and exit
  40 #     --mode=MODE          use operation mode MODE
  41 #     --preserve-dup-deps  don't remove duplicate dependency libraries
  42 #     --quiet, --silent    don't print informational messages
  43 #     --tag=TAG            use configuration variables from tag TAG
  44 # -v, --verbose            print informational messages (default)
  45 #     --version            print version information
  46 # -h, --help               print short or long help message
  47 #
  48 # MODE must be one of the following:
  49 #
  50 #       clean              remove files from the build directory
  51 #       compile            compile a source file into a libtool object
  52 #       execute            automatically set library path, then run a program
  53 #       finish             complete the installation of libtool libraries
  54 #       install            install libraries or executables
  55 #       link               create a library or an executable
  56 #       uninstall          remove libraries from an installed directory
  57 #
  58 # MODE-ARGS vary depending on the MODE.
  59 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
  60 #
  61 # When reporting a bug, please describe a test case to reproduce it and
  62 # include the following information:
  63 #
  64 #       host-triplet:   $host
  65 #       shell:          $SHELL
  66 #       compiler:               $LTCC
  67 #       compiler flags:         $LTCFLAGS
  68 #       linker:         $LD (gnu? $with_gnu_ld)
  69 #       $progname:              (GNU libtool) 2.2.6b
  70 #       automake:               $automake_version
  71 #       autoconf:               $autoconf_version
  72 #
  73 # Report bugs to <bug-libtool@gnu.org>.
  74
  75 PROGRAM=ltmain.sh
  76 PACKAGE=libtool
  77 VERSION=2.2.6b
  78 TIMESTAMP=""
  79 package_revision=1.3017
  80
  81 # Be Bourne compatible
  82 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  83   emulate sh
  84   NULLCMD=:
  85   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  86   # is contrary to our usage.  Disable this feature.
  87   alias -g '${1+"$@"}'='"$@"'
  88   setopt NO_GLOB_SUBST
  89 else
  90   case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
  91 fi
  92 BIN_SH=xpg4; export BIN_SH # for Tru64
  93 DUALCASE=1; export DUALCASE # for MKS sh
  94
  95 # NLS nuisances: We save the old values to restore during execute mode.
  96 # Only set LANG and LC_ALL to C if already set.
  97 # These must not be set unconditionally because not all systems understand
  98 # e.g. LANG=C (notably SCO).
  99 lt_user_locale=
 100 lt_safe_locale=
 101 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
 102 do
 103   eval "if test \"\${$lt_var+set}\" = set; then
 104           save_$lt_var=\$$lt_var
 105           $lt_var=C
 106           export $lt_var
 107           lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
 108           lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
 109         fi"
 110 done
 111
 112 $lt_unset CDPATH
 113
 114
 115
 116
 117
 118 : ${CP="cp -f"}
 119 : ${ECHO="echo"}
 120 : ${EGREP="/bin/grep -E"}
 121 : ${FGREP="/bin/grep -F"}
 122 : ${GREP="/bin/grep"}
 123 : ${LN_S="ln -s"}
 124 : ${MAKE="make"}
 125 : ${MKDIR="mkdir"}
 126 : ${MV="mv -f"}
 127 : ${RM="rm -f"}
 128 : ${SED="/bin/sed"}
 129 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
 130 : ${Xsed="$SED -e 1s/^X//"}
 131
 132 # Global variables:
 133 EXIT_SUCCESS=0
 134 EXIT_FAILURE=1
 135 EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
 136 EXIT_SKIP=77      # $? = 77 is used to indicate a skipped test to automake.
 137
 138 exit_status=$EXIT_SUCCESS
 139
 140 # Make sure IFS has a sensible default
 141 lt_nl='
 142 '
 143 IFS="   $lt_nl"
 144
 145 dirname="s,/[^/]*$,,"
 146 basename="s,^.*/,,"
 147
 148 # func_dirname_and_basename file append nondir_replacement
 149 # perform func_basename and func_dirname in a single function
 150 # call:
 151 #   dirname:  Compute the dirname of FILE.  If nonempty,
 152 #             add APPEND to the result, otherwise set result
 153 #             to NONDIR_REPLACEMENT.
 154 #             value returned in "$func_dirname_result"
 155 #   basename: Compute filename of FILE.
 156 #             value retuned in "$func_basename_result"
 157 # Implementation must be kept synchronized with func_dirname
 158 # and func_basename. For efficiency, we do not delegate to
 159 # those functions but instead duplicate the functionality here.
 160 func_dirname_and_basename ()
 161 {
 162   # Extract subdirectory from the argument.
 163   func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
 164   if test "X$func_dirname_result" = "X${1}"; then
 165     func_dirname_result="${3}"
 166   else
 167     func_dirname_result="$func_dirname_result${2}"
 168   fi
 169   func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
 170 }
 171
 172 # Generated shell functions inserted here.
 173
 174 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
 175 # is ksh but when the shell is invoked as "sh" and the current value of
 176 # the _XPG environment variable is not equal to 1 (one), the special
 177 # positional parameter $0, within a function call, is the name of the
 178 # function.
 179 progpath="$0"
 180
 181 # The name of this program:
 182 # In the unlikely event $progname began with a '-', it would play havoc with
 183 # func_echo (imagine progname=-n), so we prepend ./ in that case:
 184 func_dirname_and_basename "$progpath"
 185 progname=$func_basename_result
 186 case $progname in
 187   -*) progname=./$progname ;;
 188 esac
 189
 190 # Make sure we have an absolute path for reexecution:
 191 case $progpath in
 192   [\\/]*|[A-Za-z]:\\*) ;;
 193   *[\\/]*)
 194      progdir=$func_dirname_result
 195      progdir=`cd "$progdir" && pwd`
 196      progpath="$progdir/$progname"
 197      ;;
 198   *)
 199      save_IFS="$IFS"
 200      IFS=:
 201      for progdir in $PATH; do
 202        IFS="$save_IFS"
 203        test -x "$progdir/$progname" && break
 204      done
 205      IFS="$save_IFS"
 206      test -n "$progdir" || progdir=`pwd`
 207      progpath="$progdir/$progname"
 208      ;;
 209 esac
 210
 211 # Sed substitution that helps us do robust quoting.  It backslashifies
 212 # metacharacters that are still active within double-quoted strings.
 213 Xsed="${SED}"' -e 1s/^X//'
 214 sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
 215
 216 # Same as above, but do not quote variable references.
 217 double_quote_subst='s/\(["`\\]\)/\\\1/g'
 218
 219 # Re-`\' parameter expansions in output of double_quote_subst that were
 220 # `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
 221 # in input to double_quote_subst, that '$' was protected from expansion.
 222 # Since each input `\' is now two `\'s, look for any number of runs of
 223 # four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
 224 bs='\\'
 225 bs2='\\\\'
 226 bs4='\\\\\\\\'
 227 dollar='\$'
 228 sed_double_backslash="\
 229   s/$bs4/&\\
 230 /g
 231   s/^$bs2$dollar/$bs&/
 232   s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
 233   s/\n//g"
 234
 235 # Standard options:
 236 opt_dry_run=false
 237 opt_help=false
 238 opt_quiet=false
 239 opt_verbose=false
 240 opt_warning=:
 241
 242 # func_echo arg...
 243 # Echo program name prefixed message, along with the current mode
 244 # name if it has been set yet.
 245 func_echo ()
 246 {
 247     $ECHO "$progname${mode+: }$mode: $*"
 248 }
 249
 250 # func_verbose arg...
 251 # Echo program name prefixed message in verbose mode only.
 252 func_verbose ()
 253 {
 254     $opt_verbose && func_echo ${1+"$@"}
 255
 256     # A bug in bash halts the script if the last line of a function
 257     # fails when set -e is in force, so we need another command to
 258     # work around that:
 259     :
 260 }
 261
 262 # func_error arg...
 263 # Echo program name prefixed message to standard error.
 264 func_error ()
 265 {
 266     $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
 267 }
 268
 269 # func_warning arg...
 270 # Echo program name prefixed warning message to standard error.
 271 func_warning ()
 272 {
 273     $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
 274
 275     # bash bug again:
 276     :
 277 }
 278
 279 # func_fatal_error arg...
 280 # Echo program name prefixed message to standard error, and exit.
 281 func_fatal_error ()
 282 {
 283     func_error ${1+"$@"}
 284     exit $EXIT_FAILURE
 285 }
 286
 287 # func_fatal_help arg...
 288 # Echo program name prefixed message to standard error, followed by
 289 # a help hint, and exit.
 290 func_fatal_help ()
 291 {
 292     func_error ${1+"$@"}
 293     func_fatal_error "$help"
 294 }
 295 help="Try \`$progname --help' for more information."  ## default
 296
 297
 298 # func_grep expression filename
 299 # Check whether EXPRESSION matches any line of FILENAME, without output.
 300 func_grep ()
 301 {
 302     $GREP "$1" "$2" >/dev/null 2>&1
 303 }
 304
 305
 306 # func_mkdir_p directory-path
 307 # Make sure the entire path to DIRECTORY-PATH is available.
 308 func_mkdir_p ()
 309 {
 310     my_directory_path="$1"
 311     my_dir_list=
 312
 313     if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
 314
 315       # Protect directory names starting with `-'
 316       case $my_directory_path in
 317         -*) my_directory_path="./$my_directory_path" ;;
 318       esac
 319
 320       # While some portion of DIR does not yet exist...
 321       while test ! -d "$my_directory_path"; do
 322         # ...make a list in topmost first order.  Use a colon delimited
 323         # list incase some portion of path contains whitespace.
 324         my_dir_list="$my_directory_path:$my_dir_list"
 325
 326         # If the last portion added has no slash in it, the list is done
 327         case $my_directory_path in */*) ;; *) break ;; esac
 328
 329         # ...otherwise throw away the child directory and loop
 330         my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
 331       done
 332       my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
 333
 334       save_mkdir_p_IFS="$IFS"; IFS=':'
 335       for my_dir in $my_dir_list; do
 336         IFS="$save_mkdir_p_IFS"
 337         # mkdir can fail with a `File exist' error if two processes
 338         # try to create one of the directories concurrently.  Don't
 339         # stop in that case!
 340         $MKDIR "$my_dir" 2>/dev/null || :
 341       done
 342       IFS="$save_mkdir_p_IFS"
 343
 344       # Bail out if we (or some other process) failed to create a directory.
 345       test -d "$my_directory_path" || \
 346         func_fatal_error "Failed to create \`$1'"
 347     fi
 348 }
 349
 350
 351 # func_mktempdir [string]
 352 # Make a temporary directory that won't clash with other running
 353 # libtool processes, and avoids race conditions if possible.  If
 354 # given, STRING is the basename for that directory.
 355 func_mktempdir ()
 356 {
 357     my_template="${TMPDIR-/tmp}/${1-$progname}"
 358
 359     if test "$opt_dry_run" = ":"; then
 360       # Return a directory name, but don't create it in dry-run mode
 361       my_tmpdir="${my_template}-$$"
 362     else
 363
 364       # If mktemp works, use that first and foremost
 365       my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
 366
 367       if test ! -d "$my_tmpdir"; then
 368         # Failing that, at least try and use $RANDOM to avoid a race
 369         my_tmpdir="${my_template}-${RANDOM-0}$$"
 370
 371         save_mktempdir_umask=`umask`
 372         umask 0077
 373         $MKDIR "$my_tmpdir"
 374         umask $save_mktempdir_umask
 375       fi
 376
 377       # If we're not in dry-run mode, bomb out on failure
 378       test -d "$my_tmpdir" || \
 379         func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
 380     fi
 381
 382     $ECHO "X$my_tmpdir" | $Xsed
 383 }
 384
 385
 386 # func_quote_for_eval arg
 387 # Aesthetically quote ARG to be evaled later.
 388 # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
 389 # is double-quoted, suitable for a subsequent eval, whereas
 390 # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
 391 # which are still active within double quotes backslashified.
 392 func_quote_for_eval ()
 393 {
 394     case $1 in
 395       *[\\\`\"\$]*)
 396         func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
 397       *)
 398         func_quote_for_eval_unquoted_result="$1" ;;
 399     esac
 400
 401     case $func_quote_for_eval_unquoted_result in
 402       # Double-quote args containing shell metacharacters to delay
 403       # word splitting, command substitution and and variable
 404       # expansion for a subsequent eval.
 405       # Many Bourne shells cannot handle close brackets correctly
 406       # in scan sets, so we specify it separately.
 407       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 408         func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
 409         ;;
 410       *)
 411         func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
 412     esac
 413 }
 414
 415
 416 # func_quote_for_expand arg
 417 # Aesthetically quote ARG to be evaled later; same as above,
 418 # but do not quote variable references.
 419 func_quote_for_expand ()
 420 {
 421     case $1 in
 422       *[\\\`\"]*)
 423         my_arg=`$ECHO "X$1" | $Xsed \
 424             -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
 425       *)
 426         my_arg="$1" ;;
 427     esac
 428
 429     case $my_arg in
 430       # Double-quote args containing shell metacharacters to delay
 431       # word splitting and command substitution for a subsequent eval.
 432       # Many Bourne shells cannot handle close brackets correctly
 433       # in scan sets, so we specify it separately.
 434       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 435         my_arg="\"$my_arg\""
 436         ;;
 437     esac
 438
 439     func_quote_for_expand_result="$my_arg"
 440 }
 441
 442
 443 # func_show_eval cmd [fail_exp]
 444 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
 445 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
 446 # is given, then evaluate it.
 447 func_show_eval ()
 448 {
 449     my_cmd="$1"
 450     my_fail_exp="${2-:}"
 451
 452     ${opt_silent-false} || {
 453       func_quote_for_expand "$my_cmd"
 454       eval "func_echo $func_quote_for_expand_result"
 455     }
 456
 457     if ${opt_dry_run-false}; then :; else
 458       eval "$my_cmd"
 459       my_status=$?
 460       if test "$my_status" -eq 0; then :; else
 461         eval "(exit $my_status); $my_fail_exp"
 462       fi
 463     fi
 464 }
 465
 466
 467 # func_show_eval_locale cmd [fail_exp]
 468 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
 469 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
 470 # is given, then evaluate it.  Use the saved locale for evaluation.
 471 func_show_eval_locale ()
 472 {
 473     my_cmd="$1"
 474     my_fail_exp="${2-:}"
 475
 476     ${opt_silent-false} || {
 477       func_quote_for_expand "$my_cmd"
 478       eval "func_echo $func_quote_for_expand_result"
 479     }
 480
 481     if ${opt_dry_run-false}; then :; else
 482       eval "$lt_user_locale
 483             $my_cmd"
 484       my_status=$?
 485       eval "$lt_safe_locale"
 486       if test "$my_status" -eq 0; then :; else
 487         eval "(exit $my_status); $my_fail_exp"
 488       fi
 489     fi
 490 }
 491
 492
 493
 494
 495
 496 # func_version
 497 # Echo version message to standard output and exit.
 498 func_version ()
 499 {
 500     $SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
 501         s/^# //
 502         s/^# *$//
 503         s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
 504         p
 505      }' < "$progpath"
 506      exit $?
 507 }
 508
 509 # func_usage
 510 # Echo short help message to standard output and exit.
 511 func_usage ()
 512 {
 513     $SED -n '/^# Usage:/,/# -h/ {
 514         s/^# //
 515         s/^# *$//
 516         s/\$progname/'$progname'/
 517         p
 518     }' < "$progpath"
 519     $ECHO
 520     $ECHO "run \`$progname --help | more' for full usage"
 521     exit $?
 522 }
 523
 524 # func_help
 525 # Echo long help message to standard output and exit.
 526 func_help ()
 527 {
 528     $SED -n '/^# Usage:/,/# Report bugs to/ {
 529         s/^# //
 530         s/^# *$//
 531         s*\$progname*'$progname'*
 532         s*\$host*'"$host"'*
 533         s*\$SHELL*'"$SHELL"'*
 534         s*\$LTCC*'"$LTCC"'*
 535         s*\$LTCFLAGS*'"$LTCFLAGS"'*
 536         s*\$LD*'"$LD"'*
 537         s/\$with_gnu_ld/'"$with_gnu_ld"'/
 538         s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
 539         s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
 540         p
 541      }' < "$progpath"
 542     exit $?
 543 }
 544
 545 # func_missing_arg argname
 546 # Echo program name prefixed message to standard error and set global
 547 # exit_cmd.
 548 func_missing_arg ()
 549 {
 550     func_error "missing argument for $1"
 551     exit_cmd=exit
 552 }
 553
 554 exit_cmd=:
 555
 556
 557
 558
 559
 560 # Check that we have a working $ECHO.
 561 if test "X$1" = X--no-reexec; then
 562   # Discard the --no-reexec flag, and continue.
 563   shift
 564 elif test "X$1" = X--fallback-echo; then
 565   # Avoid inline document here, it may be left over
 566   :
 567 elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then
 568   # Yippee, $ECHO works!
 569   :
 570 else
 571   # Restart under the correct shell, and then maybe $ECHO will work.
 572   exec $SHELL "$progpath" --no-reexec ${1+"$@"}
 573 fi
 574
 575 if test "X$1" = X--fallback-echo; then
 576   # used as fallback echo
 577   shift
 578   cat <<EOF
 579 $*
 580 EOF
 581   exit $EXIT_SUCCESS
 582 fi
 583
 584 magic="%%%MAGIC variable%%%"
 585 magic_exe="%%%MAGIC EXE variable%%%"
 586
 587 # Global variables.
 588 # $mode is unset
 589 nonopt=
 590 execute_dlfiles=
 591 preserve_args=
 592 lo2o="s/\\.lo\$/.${objext}/"
 593 o2lo="s/\\.${objext}\$/.lo/"
 594 extracted_archives=
 595 extracted_serial=0
 596
 597 opt_dry_run=false
 598 opt_duplicate_deps=false
 599 opt_silent=false
 600 opt_debug=:
 601
 602 # If this variable is set in any of the actions, the command in it
 603 # will be execed at the end.  This prevents here-documents from being
 604 # left over by shells.
 605 exec_cmd=
 606
 607 # func_fatal_configuration arg...
 608 # Echo program name prefixed message to standard error, followed by
 609 # a configuration failure hint, and exit.
 610 func_fatal_configuration ()
 611 {
 612     func_error ${1+"$@"}
 613     func_error "See the $PACKAGE documentation for more information."
 614     func_fatal_error "Fatal configuration error."
 615 }
 616
 617
 618 # func_config
 619 # Display the configuration for all the tags in this script.
 620 func_config ()
 621 {
 622     re_begincf='^# ### BEGIN LIBTOOL'
 623     re_endcf='^# ### END LIBTOOL'
 624
 625     # Default configuration.
 626     $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
 627
 628     # Now print the configurations for the tags.
 629     for tagname in $taglist; do
 630       $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
 631     done
 632
 633     exit $?
 634 }
 635
 636 # func_features
 637 # Display the features supported by this script.
 638 func_features ()
 639 {
 640     $ECHO "host: $host"
 641     if test "$build_libtool_libs" = yes; then
 642       $ECHO "enable shared libraries"
 643     else
 644       $ECHO "disable shared libraries"
 645     fi
 646     if test "$build_old_libs" = yes; then
 647       $ECHO "enable static libraries"
 648     else
 649       $ECHO "disable static libraries"
 650     fi
 651
 652     exit $?
 653 }
 654
 655 # func_enable_tag tagname
 656 # Verify that TAGNAME is valid, and either flag an error and exit, or
 657 # enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
 658 # variable here.
 659 func_enable_tag ()
 660 {
 661   # Global variable:
 662   tagname="$1"
 663
 664   re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
 665   re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
 666   sed_extractcf="/$re_begincf/,/$re_endcf/p"
 667
 668   # Validate tagname.
 669   case $tagname in
 670     *[!-_A-Za-z0-9,/]*)
 671       func_fatal_error "invalid tag name: $tagname"
 672       ;;
 673   esac
 674
 675   # Don't test for the "default" C tag, as we know it's
 676   # there but not specially marked.
 677   case $tagname in
 678     CC) ;;
 679     *)
 680       if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
 681         taglist="$taglist $tagname"
 682
 683         # Evaluate the configuration.  Be careful to quote the path
 684         # and the sed script, to avoid splitting on whitespace, but
 685         # also don't use non-portable quotes within backquotes within
 686         # quotes we have to do it in 2 steps:
 687         extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
 688         eval "$extractedcf"
 689       else
 690         func_error "ignoring unknown tag $tagname"
 691       fi
 692       ;;
 693   esac
 694 }
 695
 696 # Parse options once, thoroughly.  This comes as soon as possible in
 697 # the script to make things like `libtool --version' happen quickly.
 698 {
 699
 700   # Shorthand for --mode=foo, only valid as the first argument
 701   case $1 in
 702   clean|clea|cle|cl)
 703     shift; set dummy --mode clean ${1+"$@"}; shift
 704     ;;
 705   compile|compil|compi|comp|com|co|c)
 706     shift; set dummy --mode compile ${1+"$@"}; shift
 707     ;;
 708   execute|execut|execu|exec|exe|ex|e)
 709     shift; set dummy --mode execute ${1+"$@"}; shift
 710     ;;
 711   finish|finis|fini|fin|fi|f)
 712     shift; set dummy --mode finish ${1+"$@"}; shift
 713     ;;
 714   install|instal|insta|inst|ins|in|i)
 715     shift; set dummy --mode install ${1+"$@"}; shift
 716     ;;
 717   link|lin|li|l)
 718     shift; set dummy --mode link ${1+"$@"}; shift
 719     ;;
 720   uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
 721     shift; set dummy --mode uninstall ${1+"$@"}; shift
 722     ;;
 723   esac
 724
 725   # Parse non-mode specific arguments:
 726   while test "$#" -gt 0; do
 727     opt="$1"
 728     shift
 729
 730     case $opt in
 731       --config)         func_config                                     ;;
 732
 733       --debug)          preserve_args="$preserve_args $opt"
 734                         func_echo "enabling shell trace mode"
 735                         opt_debug='set -x'
 736                         $opt_debug
 737                         ;;
 738
 739       -dlopen)          test "$#" -eq 0 && func_missing_arg "$opt" && break
 740                         execute_dlfiles="$execute_dlfiles $1"
 741                         shift
 742                         ;;
 743
 744       --dry-run | -n)   opt_dry_run=:                                   ;;
 745       --features)       func_features                                   ;;
 746       --finish)         mode="finish"                                   ;;
 747
 748       --mode)           test "$#" -eq 0 && func_missing_arg "$opt" && break
 749                         case $1 in
 750                           # Valid mode arguments:
 751                           clean)        ;;
 752                           compile)      ;;
 753                           execute)      ;;
 754                           finish)       ;;
 755                           install)      ;;
 756                           link)         ;;
 757                           relink)       ;;
 758                           uninstall)    ;;
 759
 760                           # Catch anything else as an error
 761                           *) func_error "invalid argument for $opt"
 762                              exit_cmd=exit
 763                              break
 764                              ;;
 765                         esac
 766
 767                         mode="$1"
 768                         shift
 769                         ;;
 770
 771       --preserve-dup-deps)
 772                         opt_duplicate_deps=:                            ;;
 773
 774       --quiet|--silent) preserve_args="$preserve_args $opt"
 775                         opt_silent=:
 776                         ;;
 777
 778       --verbose| -v)    preserve_args="$preserve_args $opt"
 779                         opt_silent=false
 780                         ;;
 781
 782       --tag)            test "$#" -eq 0 && func_missing_arg "$opt" && break
 783                         preserve_args="$preserve_args $opt $1"
 784                         func_enable_tag "$1"    # tagname is set here
 785                         shift
 786                         ;;
 787
 788       # Separate optargs to long options:
 789       -dlopen=*|--mode=*|--tag=*)
 790                         func_opt_split "$opt"
 791                         set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
 792                         shift
 793                         ;;
 794
 795       -\?|-h)           func_usage                                      ;;
 796       --help)           opt_help=:                                      ;;
 797       --version)        func_version                                    ;;
 798
 799       -*)               func_fatal_help "unrecognized option \`$opt'"   ;;
 800
 801       *)                nonopt="$opt"
 802                         break
 803                         ;;
 804     esac
 805   done
 806
 807
 808   case $host in
 809     *cygwin* | *mingw* | *pw32* | *cegcc*)
 810       # don't eliminate duplications in $postdeps and $predeps
 811       opt_duplicate_compiler_generated_deps=:
 812       ;;
 813     *)
 814       opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
 815       ;;
 816   esac
 817
 818   # Having warned about all mis-specified options, bail out if
 819   # anything was wrong.
 820   $exit_cmd $EXIT_FAILURE
 821 }
 822
 823 # func_check_version_match
 824 # Ensure that we are using m4 macros, and libtool script from the same
 825 # release of libtool.
 826 func_check_version_match ()
 827 {
 828   if test "$package_revision" != "$macro_revision"; then
 829     if test "$VERSION" != "$macro_version"; then
 830       if test -z "$macro_version"; then
 831         cat >&2 <<_LT_EOF
 832 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
 833 $progname: definition of this LT_INIT comes from an older release.
 834 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
 835 $progname: and run autoconf again.
 836 _LT_EOF
 837       else
 838         cat >&2 <<_LT_EOF
 839 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
 840 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
 841 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
 842 $progname: and run autoconf again.
 843 _LT_EOF
 844       fi
 845     else
 846       cat >&2 <<_LT_EOF
 847 $progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
 848 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
 849 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
 850 $progname: of $PACKAGE $VERSION and run autoconf again.
 851 _LT_EOF
 852     fi
 853
 854     exit $EXIT_MISMATCH
 855   fi
 856 }
 857
 858
 859 ## ----------- ##
 860 ##    Main.    ##
 861 ## ----------- ##
 862
 863 $opt_help || {
 864   # Sanity checks first:
 865   func_check_version_match
 866
 867   if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
 868     func_fatal_configuration "not configured to build any kind of library"
 869   fi
 870
 871   test -z "$mode" && func_fatal_error "error: you must specify a MODE."
 872
 873
 874   # Darwin sucks
 875   eval std_shrext=\"$shrext_cmds\"
 876
 877
 878   # Only execute mode is allowed to have -dlopen flags.
 879   if test -n "$execute_dlfiles" && test "$mode" != execute; then
 880     func_error "unrecognized option \`-dlopen'"
 881     $ECHO "$help" 1>&2
 882     exit $EXIT_FAILURE
 883   fi
 884
 885   # Change the help message to a mode-specific one.
 886   generic_help="$help"
 887   help="Try \`$progname --help --mode=$mode' for more information."
 888 }
 889
 890
 891 # func_lalib_p file
 892 # True iff FILE is a libtool `.la' library or `.lo' object file.
 893 # This function is only a basic sanity check; it will hardly flush out
 894 # determined imposters.
 895 func_lalib_p ()
 896 {
 897     test -f "$1" &&
 898       $SED -e 4q "$1" 2>/dev/null \
 899         | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
 900 }
 901
 902 # func_lalib_unsafe_p file
 903 # True iff FILE is a libtool `.la' library or `.lo' object file.
 904 # This function implements the same check as func_lalib_p without
 905 # resorting to external programs.  To this end, it redirects stdin and
 906 # closes it afterwards, without saving the original file descriptor.
 907 # As a safety measure, use it only where a negative result would be
 908 # fatal anyway.  Works if `file' does not exist.
 909 func_lalib_unsafe_p ()
 910 {
 911     lalib_p=no
 912     if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
 913         for lalib_p_l in 1 2 3 4
 914         do
 915             read lalib_p_line
 916             case "$lalib_p_line" in
 917                 \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
 918             esac
 919         done
 920         exec 0<&5 5<&-
 921     fi
 922     test "$lalib_p" = yes
 923 }
 924
 925 # func_ltwrapper_script_p file
 926 # True iff FILE is a libtool wrapper script
 927 # This function is only a basic sanity check; it will hardly flush out
 928 # determined imposters.
 929 func_ltwrapper_script_p ()
 930 {
 931     func_lalib_p "$1"
 932 }
 933
 934 # func_ltwrapper_executable_p file
 935 # True iff FILE is a libtool wrapper executable
 936 # This function is only a basic sanity check; it will hardly flush out
 937 # determined imposters.
 938 func_ltwrapper_executable_p ()
 939 {
 940     func_ltwrapper_exec_suffix=
 941     case $1 in
 942     *.exe) ;;
 943     *) func_ltwrapper_exec_suffix=.exe ;;
 944     esac
 945     $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
 946 }
 947
 948 # func_ltwrapper_scriptname file
 949 # Assumes file is an ltwrapper_executable
 950 # uses $file to determine the appropriate filename for a
 951 # temporary ltwrapper_script.
 952 func_ltwrapper_scriptname ()
 953 {
 954     func_ltwrapper_scriptname_result=""
 955     if func_ltwrapper_executable_p "$1"; then
 956         func_dirname_and_basename "$1" "" "."
 957         func_stripname '' '.exe' "$func_basename_result"
 958         func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
 959     fi
 960 }
 961
 962 # func_ltwrapper_p file
 963 # True iff FILE is a libtool wrapper script or wrapper executable
 964 # This function is only a basic sanity check; it will hardly flush out
 965 # determined imposters.
 966 func_ltwrapper_p ()
 967 {
 968     func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
 969 }
 970
 971
 972 # func_execute_cmds commands fail_cmd
 973 # Execute tilde-delimited COMMANDS.
 974 # If FAIL_CMD is given, eval that upon failure.
 975 # FAIL_CMD may read-access the current command in variable CMD!
 976 func_execute_cmds ()
 977 {
 978     $opt_debug
 979     save_ifs=$IFS; IFS='~'
 980     for cmd in $1; do
 981       IFS=$save_ifs
 982       eval cmd=\"$cmd\"
 983       func_show_eval "$cmd" "${2-:}"
 984     done
 985     IFS=$save_ifs
 986 }
 987
 988
 989 # func_source file
 990 # Source FILE, adding directory component if necessary.
 991 # Note that it is not necessary on cygwin/mingw to append a dot to
 992 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
 993 # behavior happens only for exec(3), not for open(2)!  Also, sourcing
 994 # `FILE.' does not work on cygwin managed mounts.
 995 func_source ()
 996 {
 997     $opt_debug
 998     case $1 in
 999     */* | *\\*) . "$1" ;;
1000     *)          . "./$1" ;;
1001     esac
1002 }
1003
1004
1005 # func_infer_tag arg
1006 # Infer tagged configuration to use if any are available and
1007 # if one wasn't chosen via the "--tag" command line option.
1008 # Only attempt this if the compiler in the base compile
1009 # command doesn't match the default compiler.
1010 # arg is usually of the form 'gcc ...'
1011 func_infer_tag ()
1012 {
1013     $opt_debug
1014     if test -n "$available_tags" && test -z "$tagname"; then
1015       CC_quoted=
1016       for arg in $CC; do
1017         func_quote_for_eval "$arg"
1018         CC_quoted="$CC_quoted $func_quote_for_eval_result"
1019       done
1020       case $@ in
1021       # Blanks in the command may have been stripped by the calling shell,
1022       # but not from the CC environment variable when configure was run.
1023       " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
1024       # Blanks at the start of $base_compile will cause this to fail
1025       # if we don't check for them as well.
1026       *)
1027         for z in $available_tags; do
1028           if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1029             # Evaluate the configuration.
1030             eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1031             CC_quoted=
1032             for arg in $CC; do
1033               # Double-quote args containing other shell metacharacters.
1034               func_quote_for_eval "$arg"
1035               CC_quoted="$CC_quoted $func_quote_for_eval_result"
1036             done
1037             case "$@ " in
1038               " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
1039               # The compiler in the base compile command matches
1040               # the one in the tagged configuration.
1041               # Assume this is the tagged configuration we want.
1042               tagname=$z
1043               break
1044               ;;
1045             esac
1046           fi
1047         done
1048         # If $tagname still isn't set, then no tagged configuration
1049         # was found and let the user know that the "--tag" command
1050         # line option must be used.
1051         if test -z "$tagname"; then
1052           func_echo "unable to infer tagged configuration"
1053           func_fatal_error "specify a tag with \`--tag'"
1054 #       else
1055 #         func_verbose "using $tagname tagged configuration"
1056         fi
1057         ;;
1058       esac
1059     fi
1060 }
1061
1062
1063
1064 # func_write_libtool_object output_name pic_name nonpic_name
1065 # Create a libtool object file (analogous to a ".la" file),
1066 # but don't create it if we're doing a dry run.
1067 func_write_libtool_object ()
1068 {
1069     write_libobj=${1}
1070     if test "$build_libtool_libs" = yes; then
1071       write_lobj=\'${2}\'
1072     else
1073       write_lobj=none
1074     fi
1075
1076     if test "$build_old_libs" = yes; then
1077       write_oldobj=\'${3}\'
1078     else
1079       write_oldobj=none
1080     fi
1081
1082     $opt_dry_run || {
1083       cat >${write_libobj}T <<EOF
1084 # $write_libobj - a libtool object file
1085 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1086 #
1087 # Please DO NOT delete this file!
1088 # It is necessary for linking the library.
1089
1090 # Name of the PIC object.
1091 pic_object=$write_lobj
1092
1093 # Name of the non-PIC object
1094 non_pic_object=$write_oldobj
1095
1096 EOF
1097       $MV "${write_libobj}T" "${write_libobj}"
1098     }
1099 }
1100
1101 # func_mode_compile arg...
1102 func_mode_compile ()
1103 {
1104     $opt_debug
1105     # Get the compilation command and the source file.
1106     base_compile=
1107     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
1108     suppress_opt=yes
1109     suppress_output=
1110     arg_mode=normal
1111     libobj=
1112     later=
1113     pie_flag=
1114
1115     for arg
1116     do
1117       case $arg_mode in
1118       arg  )
1119         # do not "continue".  Instead, add this to base_compile
1120         lastarg="$arg"
1121         arg_mode=normal
1122         ;;
1123
1124       target )
1125         libobj="$arg"
1126         arg_mode=normal
1127         continue
1128         ;;
1129
1130       normal )
1131         # Accept any command-line options.
1132         case $arg in
1133         -o)
1134           test -n "$libobj" && \
1135             func_fatal_error "you cannot specify \`-o' more than once"
1136           arg_mode=target
1137           continue
1138           ;;
1139
1140         -pie | -fpie | -fPIE)
1141           pie_flag="$pie_flag $arg"
1142           continue
1143           ;;
1144
1145         -shared | -static | -prefer-pic | -prefer-non-pic)
1146           later="$later $arg"
1147           continue
1148           ;;
1149
1150         -no-suppress)
1151           suppress_opt=no
1152           continue
1153           ;;
1154
1155         -Xcompiler)
1156           arg_mode=arg  #  the next one goes into the "base_compile" arg list
1157           continue      #  The current "srcfile" will either be retained or
1158           ;;            #  replaced later.  I would guess that would be a bug.
1159
1160         -Wc,*)
1161           func_stripname '-Wc,' '' "$arg"
1162           args=$func_stripname_result
1163           lastarg=
1164           save_ifs="$IFS"; IFS=','
1165           for arg in $args; do
1166             IFS="$save_ifs"
1167             func_quote_for_eval "$arg"
1168             lastarg="$lastarg $func_quote_for_eval_result"
1169           done
1170           IFS="$save_ifs"
1171           func_stripname ' ' '' "$lastarg"
1172           lastarg=$func_stripname_result
1173
1174           # Add the arguments to base_compile.
1175           base_compile="$base_compile $lastarg"
1176           continue
1177           ;;
1178
1179         *)
1180           # Accept the current argument as the source file.
1181           # The previous "srcfile" becomes the current argument.
1182           #
1183           lastarg="$srcfile"
1184           srcfile="$arg"
1185           ;;
1186         esac  #  case $arg
1187         ;;
1188       esac    #  case $arg_mode
1189
1190       # Aesthetically quote the previous argument.
1191       func_quote_for_eval "$lastarg"
1192       base_compile="$base_compile $func_quote_for_eval_result"
1193     done # for arg
1194
1195     case $arg_mode in
1196     arg)
1197       func_fatal_error "you must specify an argument for -Xcompile"
1198       ;;
1199     target)
1200       func_fatal_error "you must specify a target with \`-o'"
1201       ;;
1202     *)
1203       # Get the name of the library object.
1204       test -z "$libobj" && {
1205         func_basename "$srcfile"
1206         libobj="$func_basename_result"
1207       }
1208       ;;
1209     esac
1210
1211     # Recognize several different file suffixes.
1212     # If the user specifies -o file.o, it is replaced with file.lo
1213     case $libobj in
1214     *.[cCFSifmso] | \
1215     *.ada | *.adb | *.ads | *.asm | \
1216     *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1217     *.[fF][09]? | *.for | *.java | *.obj | *.sx)
1218       func_xform "$libobj"
1219       libobj=$func_xform_result
1220       ;;
1221     esac
1222
1223     case $libobj in
1224     *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
1225     *)
1226       func_fatal_error "cannot determine name of library object from \`$libobj'"
1227       ;;
1228     esac
1229
1230     func_infer_tag $base_compile
1231
1232     for arg in $later; do
1233       case $arg in
1234       -shared)
1235         test "$build_libtool_libs" != yes && \
1236           func_fatal_configuration "can not build a shared library"
1237         build_old_libs=no
1238         continue
1239         ;;
1240
1241       -static)
1242         build_libtool_libs=no
1243         build_old_libs=yes
1244         continue
1245         ;;
1246
1247       -prefer-pic)
1248         pic_mode=yes
1249         continue
1250         ;;
1251
1252       -prefer-non-pic)
1253         pic_mode=no
1254         continue
1255         ;;
1256       esac
1257     done
1258
1259     func_quote_for_eval "$libobj"
1260     test "X$libobj" != "X$func_quote_for_eval_result" \
1261       && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'    &()|`$[]' \
1262       && func_warning "libobj name \`$libobj' may not contain shell special characters."
1263     func_dirname_and_basename "$obj" "/" ""
1264     objname="$func_basename_result"
1265     xdir="$func_dirname_result"
1266     lobj=${xdir}$objdir/$objname
1267
1268     test -z "$base_compile" && \
1269       func_fatal_help "you must specify a compilation command"
1270
1271     # Delete any leftover library objects.
1272     if test "$build_old_libs" = yes; then
1273       removelist="$obj $lobj $libobj ${libobj}T"
1274     else
1275       removelist="$lobj $libobj ${libobj}T"
1276     fi
1277
1278     # On Cygwin there's no "real" PIC flag so we must build both object types
1279     case $host_os in
1280     cygwin* | mingw* | pw32* | os2* | cegcc*)
1281       pic_mode=default
1282       ;;
1283     esac
1284     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
1285       # non-PIC code in shared libraries is not supported
1286       pic_mode=default
1287     fi
1288
1289     # Calculate the filename of the output object if compiler does
1290     # not support -o with -c
1291     if test "$compiler_c_o" = no; then
1292       output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
1293       lockfile="$output_obj.lock"
1294     else
1295       output_obj=
1296       need_locks=no
1297       lockfile=
1298     fi
1299
1300     # Lock this critical section if it is needed
1301     # We use this script file to make the link, it avoids creating a new file
1302     if test "$need_locks" = yes; then
1303       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
1304         func_echo "Waiting for $lockfile to be removed"
1305         sleep 2
1306       done
1307     elif test "$need_locks" = warn; then
1308       if test -f "$lockfile"; then
1309         $ECHO "\
1310 *** ERROR, $lockfile exists and contains:
1311 `cat $lockfile 2>/dev/null`
1312
1313 This indicates that another process is trying to use the same
1314 temporary object file, and libtool could not work around it because
1315 your compiler does not support \`-c' and \`-o' together.  If you
1316 repeat this compilation, it may succeed, by chance, but you had better
1317 avoid parallel builds (make -j) in this platform, or get a better
1318 compiler."
1319
1320         $opt_dry_run || $RM $removelist
1321         exit $EXIT_FAILURE
1322       fi
1323       removelist="$removelist $output_obj"
1324       $ECHO "$srcfile" > "$lockfile"
1325     fi
1326
1327     $opt_dry_run || $RM $removelist
1328     removelist="$removelist $lockfile"
1329     trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1330
1331     if test -n "$fix_srcfile_path"; then
1332       eval srcfile=\"$fix_srcfile_path\"
1333     fi
1334     func_quote_for_eval "$srcfile"
1335     qsrcfile=$func_quote_for_eval_result
1336
1337     # Only build a PIC object if we are building libtool libraries.
1338     if test "$build_libtool_libs" = yes; then
1339       # Without this assignment, base_compile gets emptied.
1340       fbsd_hideous_sh_bug=$base_compile
1341
1342       if test "$pic_mode" != no; then
1343         command="$base_compile $qsrcfile $pic_flag"
1344       else
1345         # Don't build PIC code
1346         command="$base_compile $qsrcfile"
1347       fi
1348
1349       func_mkdir_p "$xdir$objdir"
1350
1351       if test -z "$output_obj"; then
1352         # Place PIC objects in $objdir
1353         command="$command -o $lobj"
1354       fi
1355
1356       func_show_eval_locale "$command"  \
1357           'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
1358
1359       if test "$need_locks" = warn &&
1360          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1361         $ECHO "\
1362 *** ERROR, $lockfile contains:
1363 `cat $lockfile 2>/dev/null`
1364
1365 but it should contain:
1366 $srcfile
1367
1368 This indicates that another process is trying to use the same
1369 temporary object file, and libtool could not work around it because
1370 your compiler does not support \`-c' and \`-o' together.  If you
1371 repeat this compilation, it may succeed, by chance, but you had better
1372 avoid parallel builds (make -j) in this platform, or get a better
1373 compiler."
1374
1375         $opt_dry_run || $RM $removelist
1376         exit $EXIT_FAILURE
1377       fi
1378
1379       # Just move the object if needed, then go on to compile the next one
1380       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
1381         func_show_eval '$MV "$output_obj" "$lobj"' \
1382           'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1383       fi
1384
1385       # Allow error messages only from the first compilation.
1386       if test "$suppress_opt" = yes; then
1387         suppress_output=' >/dev/null 2>&1'
1388       fi
1389     fi
1390
1391     # Only build a position-dependent object if we build old libraries.
1392     if test "$build_old_libs" = yes; then
1393       if test "$pic_mode" != yes; then
1394         # Don't build PIC code
1395         command="$base_compile $qsrcfile$pie_flag"
1396       else
1397         command="$base_compile $qsrcfile $pic_flag"
1398       fi
1399       if test "$compiler_c_o" = yes; then
1400         command="$command -o $obj"
1401       fi
1402
1403       # Suppress compiler output if we already did a PIC compilation.
1404       command="$command$suppress_output"
1405       func_show_eval_locale "$command" \
1406         '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1407
1408       if test "$need_locks" = warn &&
1409          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1410         $ECHO "\
1411 *** ERROR, $lockfile contains:
1412 `cat $lockfile 2>/dev/null`
1413
1414 but it should contain:
1415 $srcfile
1416
1417 This indicates that another process is trying to use the same
1418 temporary object file, and libtool could not work around it because
1419 your compiler does not support \`-c' and \`-o' together.  If you
1420 repeat this compilation, it may succeed, by chance, but you had better
1421 avoid parallel builds (make -j) in this platform, or get a better
1422 compiler."
1423
1424         $opt_dry_run || $RM $removelist
1425         exit $EXIT_FAILURE
1426       fi
1427
1428       # Just move the object if needed
1429       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1430         func_show_eval '$MV "$output_obj" "$obj"' \
1431           'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1432       fi
1433     fi
1434
1435     $opt_dry_run || {
1436       func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
1437
1438       # Unlock the critical section if it was locked
1439       if test "$need_locks" != no; then
1440         removelist=$lockfile
1441         $RM "$lockfile"
1442       fi
1443     }
1444
1445     exit $EXIT_SUCCESS
1446 }
1447
1448 $opt_help || {
1449 test "$mode" = compile && func_mode_compile ${1+"$@"}
1450 }
1451
1452 func_mode_help ()
1453 {
1454     # We need to display help for each of the modes.
1455     case $mode in
1456       "")
1457         # Generic help is extracted from the usage comments
1458         # at the start of this file.
1459         func_help
1460         ;;
1461
1462       clean)
1463         $ECHO \
1464 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
1465
1466 Remove files from the build directory.
1467
1468 RM is the name of the program to use to delete files associated with each FILE
1469 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
1470 to RM.
1471
1472 If FILE is a libtool library, object or program, all the files associated
1473 with it are deleted. Otherwise, only FILE itself is deleted using RM."
1474         ;;
1475
1476       compile)
1477       $ECHO \
1478 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1479
1480 Compile a source file into a libtool library object.
1481
1482 This mode accepts the following additional options:
1483
1484   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
1485   -no-suppress      do not suppress compiler output for multiple passes
1486   -prefer-pic       try to building PIC objects only
1487   -prefer-non-pic   try to building non-PIC objects only
1488   -shared           do not build a \`.o' file suitable for static linking
1489   -static           only build a \`.o' file suitable for static linking
1490
1491 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1492 from the given SOURCEFILE.
1493
1494 The output file name is determined by removing the directory component from
1495 SOURCEFILE, then substituting the C source code suffix \`.c' with the
1496 library object suffix, \`.lo'."
1497         ;;
1498
1499       execute)
1500         $ECHO \
1501 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
1502
1503 Automatically set library path, then run a program.
1504
1505 This mode accepts the following additional options:
1506
1507   -dlopen FILE      add the directory containing FILE to the library path
1508
1509 This mode sets the library path environment variable according to \`-dlopen'
1510 flags.
1511
1512 If any of the ARGS are libtool executable wrappers, then they are translated
1513 into their corresponding uninstalled binary, and any of their required library
1514 directories are added to the library path.
1515
1516 Then, COMMAND is executed, with ARGS as arguments."
1517         ;;
1518
1519       finish)
1520         $ECHO \
1521 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
1522
1523 Complete the installation of libtool libraries.
1524
1525 Each LIBDIR is a directory that contains libtool libraries.
1526
1527 The commands that this mode executes may require superuser privileges.  Use
1528 the \`--dry-run' option if you just want to see what would be executed."
1529         ;;
1530
1531       install)
1532         $ECHO \
1533 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
1534
1535 Install executables or libraries.
1536
1537 INSTALL-COMMAND is the installation command.  The first component should be
1538 either the \`install' or \`cp' program.
1539
1540 The following components of INSTALL-COMMAND are treated specially:
1541
1542   -inst-prefix PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
1543
1544 The rest of the components are interpreted as arguments to that command (only
1545 BSD-compatible install options are recognized)."
1546         ;;
1547
1548       link)
1549         $ECHO \
1550 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
1551
1552 Link object files or libraries together to form another library, or to
1553 create an executable program.
1554
1555 LINK-COMMAND is a command using the C compiler that you would use to create
1556 a program from several object files.
1557
1558 The following components of LINK-COMMAND are treated specially:
1559
1560   -all-static       do not do any dynamic linking at all
1561   -avoid-version    do not add a version suffix if possible
1562   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
1563   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
1564   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
1565   -export-symbols SYMFILE
1566                     try to export only the symbols listed in SYMFILE
1567   -export-symbols-regex REGEX
1568                     try to export only the symbols matching REGEX
1569   -LLIBDIR          search LIBDIR for required installed libraries
1570   -lNAME            OUTPUT-FILE requires the installed library libNAME
1571   -module           build a library that can dlopened
1572   -no-fast-install  disable the fast-install mode
1573   -no-install       link a not-installable executable
1574   -no-undefined     declare that a library does not refer to external symbols
1575   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
1576   -objectlist FILE  Use a list of object files found in FILE to specify objects
1577   -precious-files-regex REGEX
1578                     don't remove output files matching REGEX
1579   -release RELEASE  specify package release information
1580   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
1581   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
1582   -shared           only do dynamic linking of libtool libraries
1583   -shrext SUFFIX    override the standard shared library file extension
1584   -static           do not do any dynamic linking of uninstalled libtool libraries
1585   -static-libtool-libs
1586                     do not do any dynamic linking of libtool libraries
1587   -version-info CURRENT[:REVISION[:AGE]]
1588                     specify library version info [each variable defaults to 0]
1589   -weak LIBNAME     declare that the target provides the LIBNAME interface
1590
1591 All other options (arguments beginning with \`-') are ignored.
1592
1593 Every other argument is treated as a filename.  Files ending in \`.la' are
1594 treated as uninstalled libtool libraries, other files are standard or library
1595 object files.
1596
1597 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
1598 only library objects (\`.lo' files) may be specified, and \`-rpath' is
1599 required, except when creating a convenience library.
1600
1601 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
1602 using \`ar' and \`ranlib', or on Windows using \`lib'.
1603
1604 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
1605 is created, otherwise an executable program is created."
1606         ;;
1607
1608       uninstall)
1609         $ECHO \
1610 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
1611
1612 Remove libraries from an installation directory.
1613
1614 RM is the name of the program to use to delete files associated with each FILE
1615 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
1616 to RM.
1617
1618 If FILE is a libtool library, all the files associated with it are deleted.
1619 Otherwise, only FILE itself is deleted using RM."
1620         ;;
1621
1622       *)
1623         func_fatal_help "invalid operation mode \`$mode'"
1624         ;;
1625     esac
1626
1627     $ECHO
1628     $ECHO "Try \`$progname --help' for more information about other modes."
1629
1630     exit $?
1631 }
1632
1633   # Now that we've collected a possible --mode arg, show help if necessary
1634   $opt_help && func_mode_help
1635
1636
1637 # func_mode_execute arg...
1638 func_mode_execute ()
1639 {
1640     $opt_debug
1641     # The first argument is the command name.
1642     cmd="$nonopt"
1643     test -z "$cmd" && \
1644       func_fatal_help "you must specify a COMMAND"
1645
1646     # Handle -dlopen flags immediately.
1647     for file in $execute_dlfiles; do
1648       test -f "$file" \
1649         || func_fatal_help "\`$file' is not a file"
1650
1651       dir=
1652       case $file in
1653       *.la)
1654         # Check to see that this really is a libtool archive.
1655         func_lalib_unsafe_p "$file" \
1656           || func_fatal_help "\`$lib' is not a valid libtool archive"
1657
1658         # Read the libtool library.
1659         dlname=
1660         library_names=
1661         func_source "$file"
1662
1663         # Skip this library if it cannot be dlopened.
1664         if test -z "$dlname"; then
1665           # Warn if it was a shared library.
1666           test -n "$library_names" && \
1667             func_warning "\`$file' was not linked with \`-export-dynamic'"
1668           continue
1669         fi
1670
1671         func_dirname "$file" "" "."
1672         dir="$func_dirname_result"
1673
1674         if test -f "$dir/$objdir/$dlname"; then
1675           dir="$dir/$objdir"
1676         else
1677           if test ! -f "$dir/$dlname"; then
1678             func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
1679           fi
1680         fi
1681         ;;
1682
1683       *.lo)
1684         # Just add the directory containing the .lo file.
1685         func_dirname "$file" "" "."
1686         dir="$func_dirname_result"
1687         ;;
1688
1689       *)
1690         func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
1691         continue
1692         ;;
1693       esac
1694
1695       # Get the absolute pathname.
1696       absdir=`cd "$dir" && pwd`
1697       test -n "$absdir" && dir="$absdir"
1698
1699       # Now add the directory to shlibpath_var.
1700       if eval "test -z \"\$$shlibpath_var\""; then
1701         eval "$shlibpath_var=\"\$dir\""
1702       else
1703         eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
1704       fi
1705     done
1706
1707     # This variable tells wrapper scripts just to set shlibpath_var
1708     # rather than running their programs.
1709     libtool_execute_magic="$magic"
1710
1711     # Check if any of the arguments is a wrapper script.
1712     args=
1713     for file
1714     do
1715       case $file in
1716       -*) ;;
1717       *)
1718         # Do a test to see if this is really a libtool program.
1719         if func_ltwrapper_script_p "$file"; then
1720           func_source "$file"
1721           # Transform arg to wrapped name.
1722           file="$progdir/$program"
1723         elif func_ltwrapper_executable_p "$file"; then
1724           func_ltwrapper_scriptname "$file"
1725           func_source "$func_ltwrapper_scriptname_result"
1726           # Transform arg to wrapped name.
1727           file="$progdir/$program"
1728         fi
1729         ;;
1730       esac
1731       # Quote arguments (to preserve shell metacharacters).
1732       func_quote_for_eval "$file"
1733       args="$args $func_quote_for_eval_result"
1734     done
1735
1736     if test "X$opt_dry_run" = Xfalse; then
1737       if test -n "$shlibpath_var"; then
1738         # Export the shlibpath_var.
1739         eval "export $shlibpath_var"
1740       fi
1741
1742       # Restore saved environment variables
1743       for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
1744       do
1745         eval "if test \"\${save_$lt_var+set}\" = set; then
1746                 $lt_var=\$save_$lt_var; export $lt_var
1747               else
1748                 $lt_unset $lt_var
1749               fi"
1750       done
1751
1752       # Now prepare to actually exec the command.
1753       exec_cmd="\$cmd$args"
1754     else
1755       # Display what would be done.
1756       if test -n "$shlibpath_var"; then
1757         eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
1758         $ECHO "export $shlibpath_var"
1759       fi
1760       $ECHO "$cmd$args"
1761       exit $EXIT_SUCCESS
1762     fi
1763 }
1764
1765 test "$mode" = execute && func_mode_execute ${1+"$@"}
1766
1767
1768 # func_mode_finish arg...
1769 func_mode_finish ()
1770 {
1771     $opt_debug
1772     libdirs="$nonopt"
1773     admincmds=
1774
1775     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
1776       for dir
1777       do
1778         libdirs="$libdirs $dir"
1779       done
1780
1781       for libdir in $libdirs; do
1782         if test -n "$finish_cmds"; then
1783           # Do each command in the finish commands.
1784           func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
1785 '"$cmd"'"'
1786         fi
1787         if test -n "$finish_eval"; then
1788           # Do the single finish_eval.
1789           eval cmds=\"$finish_eval\"
1790           $opt_dry_run || eval "$cmds" || admincmds="$admincmds
1791        $cmds"
1792         fi
1793       done
1794     fi
1795
1796     # Exit here if they wanted silent mode.
1797     $opt_silent && exit $EXIT_SUCCESS
1798
1799     $ECHO "X----------------------------------------------------------------------" | $Xsed
1800     $ECHO "Libraries have been installed in:"
1801     for libdir in $libdirs; do
1802       $ECHO "   $libdir"
1803     done
1804     $ECHO
1805     $ECHO "If you ever happen to want to link against installed libraries"
1806     $ECHO "in a given directory, LIBDIR, you must either use libtool, and"
1807     $ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'"
1808     $ECHO "flag during linking and do at least one of the following:"
1809     if test -n "$shlibpath_var"; then
1810       $ECHO "   - add LIBDIR to the \`$shlibpath_var' environment variable"
1811       $ECHO "     during execution"
1812     fi
1813     if test -n "$runpath_var"; then
1814       $ECHO "   - add LIBDIR to the \`$runpath_var' environment variable"
1815       $ECHO "     during linking"
1816     fi
1817     if test -n "$hardcode_libdir_flag_spec"; then
1818       libdir=LIBDIR
1819       eval flag=\"$hardcode_libdir_flag_spec\"
1820
1821       $ECHO "   - use the \`$flag' linker flag"
1822     fi
1823     if test -n "$admincmds"; then
1824       $ECHO "   - have your system administrator run these commands:$admincmds"
1825     fi
1826     if test -f /etc/ld.so.conf; then
1827       $ECHO "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
1828     fi
1829     $ECHO
1830
1831     $ECHO "See any operating system documentation about shared libraries for"
1832     case $host in
1833       solaris2.[6789]|solaris2.1[0-9])
1834         $ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
1835         $ECHO "pages."
1836         ;;
1837       *)
1838         $ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
1839         ;;
1840     esac
1841     $ECHO "X----------------------------------------------------------------------" | $Xsed
1842     exit $EXIT_SUCCESS
1843 }
1844
1845 test "$mode" = finish && func_mode_finish ${1+"$@"}
1846
1847
1848 # func_mode_install arg...
1849 func_mode_install ()
1850 {
1851     $opt_debug
1852     # There may be an optional sh(1) argument at the beginning of
1853     # install_prog (especially on Windows NT).
1854     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
1855        # Allow the use of GNU shtool's install command.
1856        $ECHO "X$nonopt" | $GREP shtool >/dev/null; then
1857       # Aesthetically quote it.
1858       func_quote_for_eval "$nonopt"
1859       install_prog="$func_quote_for_eval_result "
1860       arg=$1
1861       shift
1862     else
1863       install_prog=
1864       arg=$nonopt
1865     fi
1866
1867     # The real first argument should be the name of the installation program.
1868     # Aesthetically quote it.
1869     func_quote_for_eval "$arg"
1870     install_prog="$install_prog$func_quote_for_eval_result"
1871
1872     # We need to accept at least all the BSD install flags.
1873     dest=
1874     files=
1875     opts=
1876     prev=
1877     install_type=
1878     isdir=no
1879     stripme=
1880     for arg
1881     do
1882       if test -n "$dest"; then
1883         files="$files $dest"
1884         dest=$arg
1885         continue
1886       fi
1887
1888       case $arg in
1889       -d) isdir=yes ;;
1890       -f)
1891         case " $install_prog " in
1892         *[\\\ /]cp\ *) ;;
1893         *) prev=$arg ;;
1894         esac
1895         ;;
1896       -g | -m | -o)
1897         prev=$arg
1898         ;;
1899       -s)
1900         stripme=" -s"
1901         continue
1902         ;;
1903       -*)
1904         ;;
1905       *)
1906         # If the previous option needed an argument, then skip it.
1907         if test -n "$prev"; then
1908           prev=
1909         else
1910           dest=$arg
1911           continue
1912         fi
1913         ;;
1914       esac
1915
1916       # Aesthetically quote the argument.
1917       func_quote_for_eval "$arg"
1918       install_prog="$install_prog $func_quote_for_eval_result"
1919     done
1920
1921     test -z "$install_prog" && \
1922       func_fatal_help "you must specify an install program"
1923
1924     test -n "$prev" && \
1925       func_fatal_help "the \`$prev' option requires an argument"
1926
1927     if test -z "$files"; then
1928       if test -z "$dest"; then
1929         func_fatal_help "no file or destination specified"
1930       else
1931         func_fatal_help "you must specify a destination"
1932       fi
1933     fi
1934
1935     # Strip any trailing slash from the destination.
1936     func_stripname '' '/' "$dest"
1937     dest=$func_stripname_result
1938
1939     # Check to see that the destination is a directory.
1940     test -d "$dest" && isdir=yes
1941     if test "$isdir" = yes; then
1942       destdir="$dest"
1943       destname=
1944     else
1945       func_dirname_and_basename "$dest" "" "."
1946       destdir="$func_dirname_result"
1947       destname="$func_basename_result"
1948
1949       # Not a directory, so check to see that there is only one file specified.
1950       set dummy $files; shift
1951       test "$#" -gt 1 && \
1952         func_fatal_help "\`$dest' is not a directory"
1953     fi
1954     case $destdir in
1955     [\\/]* | [A-Za-z]:[\\/]*) ;;
1956     *)
1957       for file in $files; do
1958         case $file in
1959         *.lo) ;;
1960         *)
1961           func_fatal_help "\`$destdir' must be an absolute directory name"
1962           ;;
1963         esac
1964       done
1965       ;;
1966     esac
1967
1968     # This variable tells wrapper scripts just to set variables rather
1969     # than running their programs.
1970     libtool_install_magic="$magic"
1971
1972     staticlibs=
1973     future_libdirs=
1974     current_libdirs=
1975     for file in $files; do
1976
1977       # Do each installation.
1978       case $file in
1979       *.$libext)
1980         # Do the static libraries later.
1981         staticlibs="$staticlibs $file"
1982         ;;
1983
1984       *.la)
1985         # Check to see that this really is a libtool archive.
1986         func_lalib_unsafe_p "$file" \
1987           || func_fatal_help "\`$file' is not a valid libtool archive"
1988
1989         library_names=
1990         old_library=
1991         relink_command=
1992         func_source "$file"
1993
1994         # Add the libdir to current_libdirs if it is the destination.
1995         if test "X$destdir" = "X$libdir"; then
1996           case "$current_libdirs " in
1997           *" $libdir "*) ;;
1998           *) current_libdirs="$current_libdirs $libdir" ;;
1999           esac
2000         else
2001           # Note the libdir as a future libdir.
2002           case "$future_libdirs " in
2003           *" $libdir "*) ;;
2004           *) future_libdirs="$future_libdirs $libdir" ;;
2005           esac
2006         fi
2007
2008         func_dirname "$file" "/" ""
2009         dir="$func_dirname_result"
2010         dir="$dir$objdir"
2011
2012         if test -n "$relink_command"; then
2013           # Determine the prefix the user has applied to our future dir.
2014           inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
2015
2016           # Don't allow the user to place us outside of our expected
2017           # location b/c this prevents finding dependent libraries that
2018           # are installed to the same prefix.
2019           # At present, this check doesn't affect windows .dll's that
2020           # are installed into $libdir/../bin (currently, that works fine)
2021           # but it's something to keep an eye on.
2022           test "$inst_prefix_dir" = "$destdir" && \
2023             func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2024
2025           if test -n "$inst_prefix_dir"; then
2026             # Stick the inst_prefix_dir data into the link command.
2027             relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2028           else
2029             relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
2030           fi
2031
2032           func_warning "relinking \`$file'"
2033           func_show_eval "$relink_command" \
2034             'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2035         fi
2036
2037         # See the names of the shared library.
2038         set dummy $library_names; shift
2039         if test -n "$1"; then
2040           realname="$1"
2041           shift
2042
2043           srcname="$realname"
2044           test -n "$relink_command" && srcname="$realname"T
2045
2046           # Install the shared library and build the symlinks.
2047           func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
2048               'exit $?'
2049           tstripme="$stripme"
2050           case $host_os in
2051           cygwin* | mingw* | pw32* | cegcc*)
2052             case $realname in
2053             *.dll.a)
2054               tstripme=""
2055               ;;
2056             esac
2057             ;;
2058           esac
2059           if test -n "$tstripme" && test -n "$striplib"; then
2060             func_show_eval "$striplib $destdir/$realname" 'exit $?'
2061           fi
2062
2063           if test "$#" -gt 0; then
2064             # Delete the old symlinks, and create new ones.
2065             # Try `ln -sf' first, because the `ln' binary might depend on
2066             # the symlink we replace!  Solaris /bin/ln does not understand -f,
2067             # so we also need to try rm && ln -s.
2068             for linkname
2069             do
2070               test "$linkname" != "$realname" \
2071                 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2072             done
2073           fi
2074
2075           # Do each command in the postinstall commands.
2076           lib="$destdir/$realname"
2077           func_execute_cmds "$postinstall_cmds" 'exit $?'
2078         fi
2079
2080         # Install the pseudo-library for information purposes.
2081         func_basename "$file"
2082         name="$func_basename_result"
2083         instname="$dir/$name"i
2084         func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2085
2086         # Maybe install the static library, too.
2087         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2088         ;;
2089
2090       *.lo)
2091         # Install (i.e. copy) a libtool object.
2092
2093         # Figure out destination file name, if it wasn't already specified.
2094         if test -n "$destname"; then
2095           destfile="$destdir/$destname"
2096         else
2097           func_basename "$file"
2098           destfile="$func_basename_result"
2099           destfile="$destdir/$destfile"
2100         fi
2101
2102         # Deduce the name of the destination old-style object file.
2103         case $destfile in
2104         *.lo)
2105           func_lo2o "$destfile"
2106           staticdest=$func_lo2o_result
2107           ;;
2108         *.$objext)
2109           staticdest="$destfile"
2110           destfile=
2111           ;;
2112         *)
2113           func_fatal_help "cannot copy a libtool object to \`$destfile'"
2114           ;;
2115         esac
2116
2117         # Install the libtool object if requested.
2118         test -n "$destfile" && \
2119           func_show_eval "$install_prog $file $destfile" 'exit $?'
2120
2121         # Install the old object if enabled.
2122         if test "$build_old_libs" = yes; then
2123           # Deduce the name of the old-style object file.
2124           func_lo2o "$file"
2125           staticobj=$func_lo2o_result
2126           func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2127         fi
2128         exit $EXIT_SUCCESS
2129         ;;
2130
2131       *)
2132         # Figure out destination file name, if it wasn't already specified.
2133         if test -n "$destname"; then
2134           destfile="$destdir/$destname"
2135         else
2136           func_basename "$file"
2137           destfile="$func_basename_result"
2138           destfile="$destdir/$destfile"
2139         fi
2140
2141         # If the file is missing, and there is a .exe on the end, strip it
2142         # because it is most likely a libtool script we actually want to
2143         # install
2144         stripped_ext=""
2145         case $file in
2146           *.exe)
2147             if test ! -f "$file"; then
2148               func_stripname '' '.exe' "$file"
2149               file=$func_stripname_result
2150               stripped_ext=".exe"
2151             fi
2152             ;;
2153         esac
2154
2155         # Do a test to see if this is really a libtool program.
2156         case $host in
2157         *cygwin* | *mingw*)
2158             if func_ltwrapper_executable_p "$file"; then
2159               func_ltwrapper_scriptname "$file"
2160               wrapper=$func_ltwrapper_scriptname_result
2161             else
2162               func_stripname '' '.exe' "$file"
2163               wrapper=$func_stripname_result
2164             fi
2165             ;;
2166         *)
2167             wrapper=$file
2168             ;;
2169         esac
2170         if func_ltwrapper_script_p "$wrapper"; then
2171           notinst_deplibs=
2172           relink_command=
2173
2174           func_source "$wrapper"
2175
2176           # Check the variables that should have been set.
2177           test -z "$generated_by_libtool_version" && \
2178             func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2179
2180           finalize=yes
2181           for lib in $notinst_deplibs; do
2182             # Check to see that each library is installed.
2183             libdir=
2184             if test -f "$lib"; then
2185               func_source "$lib"
2186             fi
2187             libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
2188             if test -n "$libdir" && test ! -f "$libfile"; then
2189               func_warning "\`$lib' has not been installed in \`$libdir'"
2190               finalize=no
2191             fi
2192           done
2193
2194           relink_command=
2195           func_source "$wrapper"
2196
2197           outputname=
2198           if test "$fast_install" = no && test -n "$relink_command"; then
2199             $opt_dry_run || {
2200               if test "$finalize" = yes; then
2201                 tmpdir=`func_mktempdir`
2202                 func_basename "$file$stripped_ext"
2203                 file="$func_basename_result"
2204                 outputname="$tmpdir/$file"
2205                 # Replace the output file specification.
2206                 relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
2207
2208                 $opt_silent || {
2209                   func_quote_for_expand "$relink_command"
2210                   eval "func_echo $func_quote_for_expand_result"
2211                 }
2212                 if eval "$relink_command"; then :
2213                   else
2214                   func_error "error: relink \`$file' with the above command before installing it"
2215                   $opt_dry_run || ${RM}r "$tmpdir"
2216                   continue
2217                 fi
2218                 file="$outputname"
2219               else
2220                 func_warning "cannot relink \`$file'"
2221               fi
2222             }
2223           else
2224             # Install the binary that we compiled earlier.
2225             file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
2226           fi
2227         fi
2228
2229         # remove .exe since cygwin /usr/bin/install will append another
2230         # one anyway
2231         case $install_prog,$host in
2232         */usr/bin/install*,*cygwin*)
2233           case $file:$destfile in
2234           *.exe:*.exe)
2235             # this is ok
2236             ;;
2237           *.exe:*)
2238             destfile=$destfile.exe
2239             ;;
2240           *:*.exe)
2241             func_stripname '' '.exe' "$destfile"
2242             destfile=$func_stripname_result
2243             ;;
2244           esac
2245           ;;
2246         esac
2247         func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2248         $opt_dry_run || if test -n "$outputname"; then
2249           ${RM}r "$tmpdir"
2250         fi
2251         ;;
2252       esac
2253     done
2254
2255     for file in $staticlibs; do
2256       func_basename "$file"
2257       name="$func_basename_result"
2258
2259       # Set up the ranlib parameters.
2260       oldlib="$destdir/$name"
2261
2262       func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2263
2264       if test -n "$stripme" && test -n "$old_striplib"; then
2265         func_show_eval "$old_striplib $oldlib" 'exit $?'
2266       fi
2267
2268       # Do each command in the postinstall commands.
2269       func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2270     done
2271
2272     test -n "$future_libdirs" && \
2273       func_warning "remember to run \`$progname --finish$future_libdirs'"
2274
2275     if test -n "$current_libdirs"; then
2276       # Maybe just do a dry run.
2277       $opt_dry_run && current_libdirs=" -n$current_libdirs"
2278       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2279     else
2280       exit $EXIT_SUCCESS
2281     fi
2282 }
2283
2284 test "$mode" = install && func_mode_install ${1+"$@"}
2285
2286
2287 # func_generate_dlsyms outputname originator pic_p
2288 # Extract symbols from dlprefiles and create ${outputname}S.o with
2289 # a dlpreopen symbol table.
2290 func_generate_dlsyms ()
2291 {
2292     $opt_debug
2293     my_outputname="$1"
2294     my_originator="$2"
2295     my_pic_p="${3-no}"
2296     my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
2297     my_dlsyms=
2298
2299     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2300       if test -n "$NM" && test -n "$global_symbol_pipe"; then
2301         my_dlsyms="${my_outputname}S.c"
2302       else
2303         func_error "not configured to extract global symbols from dlpreopened files"
2304       fi
2305     fi
2306
2307     if test -n "$my_dlsyms"; then
2308       case $my_dlsyms in
2309       "") ;;
2310       *.c)
2311         # Discover the nlist of each of the dlfiles.
2312         nlist="$output_objdir/${my_outputname}.nm"
2313
2314         func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2315
2316         # Parse the name list into a source file.
2317         func_verbose "creating $output_objdir/$my_dlsyms"
2318
2319         $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
2320 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2321 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2322
2323 #ifdef __cplusplus
2324 extern \"C\" {
2325 #endif
2326
2327 /* External symbol declarations for the compiler. */\
2328 "
2329
2330         if test "$dlself" = yes; then
2331           func_verbose "generating symbol list for \`$output'"
2332
2333           $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2334
2335           # Add our own program objects to the symbol list.
2336           progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2337           for progfile in $progfiles; do
2338             func_verbose "extracting global C symbols from \`$progfile'"
2339             $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
2340           done
2341
2342           if test -n "$exclude_expsyms"; then
2343             $opt_dry_run || {
2344               eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
2345               eval '$MV "$nlist"T "$nlist"'
2346             }
2347           fi
2348
2349           if test -n "$export_symbols_regex"; then
2350             $opt_dry_run || {
2351               eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
2352               eval '$MV "$nlist"T "$nlist"'
2353             }
2354           fi
2355
2356           # Prepare the list of exported symbols
2357           if test -z "$export_symbols"; then
2358             export_symbols="$output_objdir/$outputname.exp"
2359             $opt_dry_run || {
2360               $RM $export_symbols
2361               eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
2362               case $host in
2363               *cygwin* | *mingw* | *cegcc* )
2364                 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2365                 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
2366                 ;;
2367               esac
2368             }
2369           else
2370             $opt_dry_run || {
2371               eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
2372               eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
2373               eval '$MV "$nlist"T "$nlist"'
2374               case $host in
2375                 *cygwin | *mingw* | *cegcc* )
2376                   eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2377                   eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
2378                   ;;
2379               esac
2380             }
2381           fi
2382         fi
2383
2384         for dlprefile in $dlprefiles; do
2385           func_verbose "extracting global C symbols from \`$dlprefile'"
2386           func_basename "$dlprefile"
2387           name="$func_basename_result"
2388           $opt_dry_run || {
2389             eval '$ECHO ": $name " >> "$nlist"'
2390             eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2391           }
2392         done
2393
2394         $opt_dry_run || {
2395           # Make sure we have at least an empty file.
2396           test -f "$nlist" || : > "$nlist"
2397
2398           if test -n "$exclude_expsyms"; then
2399             $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2400             $MV "$nlist"T "$nlist"
2401           fi
2402
2403           # Try sorting and uniquifying the output.
2404           if $GREP -v "^: " < "$nlist" |
2405               if sort -k 3 </dev/null >/dev/null 2>&1; then
2406                 sort -k 3
2407               else
2408                 sort +2
2409               fi |
2410               uniq > "$nlist"S; then
2411             :
2412           else
2413             $GREP -v "^: " < "$nlist" > "$nlist"S
2414           fi
2415
2416           if test -f "$nlist"S; then
2417             eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2418           else
2419             $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
2420           fi
2421
2422           $ECHO >> "$output_objdir/$my_dlsyms" "\
2423
2424 /* The mapping between symbol names and symbols.  */
2425 typedef struct {
2426   const char *name;
2427   void *address;
2428 } lt_dlsymlist;
2429 "
2430           case $host in
2431           *cygwin* | *mingw* | *cegcc* )
2432             $ECHO >> "$output_objdir/$my_dlsyms" "\
2433 /* DATA imports from DLLs on WIN32 con't be const, because
2434    runtime relocations are performed -- see ld's documentation
2435    on pseudo-relocs.  */"
2436             lt_dlsym_const= ;;
2437           *osf5*)
2438             echo >> "$output_objdir/$my_dlsyms" "\
2439 /* This system does not cope well with relocations in const data */"
2440             lt_dlsym_const= ;;
2441           *)
2442             lt_dlsym_const=const ;;
2443           esac
2444
2445           $ECHO >> "$output_objdir/$my_dlsyms" "\
2446 extern $lt_dlsym_const lt_dlsymlist
2447 lt_${my_prefix}_LTX_preloaded_symbols[];
2448 $lt_dlsym_const lt_dlsymlist
2449 lt_${my_prefix}_LTX_preloaded_symbols[] =
2450 {\
2451   { \"$my_originator\", (void *) 0 },"
2452
2453           case $need_lib_prefix in
2454           no)
2455             eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2456             ;;
2457           *)
2458             eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2459             ;;
2460           esac
2461           $ECHO >> "$output_objdir/$my_dlsyms" "\
2462   {0, (void *) 0}
2463 };
2464
2465 /* This works around a problem in FreeBSD linker */
2466 #ifdef FREEBSD_WORKAROUND
2467 static const void *lt_preloaded_setup() {
2468   return lt_${my_prefix}_LTX_preloaded_symbols;
2469 }
2470 #endif
2471
2472 #ifdef __cplusplus
2473 }
2474 #endif\
2475 "
2476         } # !$opt_dry_run
2477
2478         pic_flag_for_symtable=
2479         case "$compile_command " in
2480         *" -static "*) ;;
2481         *)
2482           case $host in
2483           # compiling the symbol table file with pic_flag works around
2484           # a FreeBSD bug that causes programs to crash when -lm is
2485           # linked before any other PIC object.  But we must not use
2486           # pic_flag when linking with -static.  The problem exists in
2487           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2488           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2489             pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2490           *-*-hpux*)
2491             pic_flag_for_symtable=" $pic_flag"  ;;
2492           *)
2493             if test "X$my_pic_p" != Xno; then
2494               pic_flag_for_symtable=" $pic_flag"
2495             fi
2496             ;;
2497           esac
2498           ;;
2499         esac
2500         symtab_cflags=
2501         for arg in $LTCFLAGS; do
2502           case $arg in
2503           -pie | -fpie | -fPIE) ;;
2504           *) symtab_cflags="$symtab_cflags $arg" ;;
2505           esac
2506         done
2507
2508         # Now compile the dynamic symbol file.
2509         func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
2510
2511         # Clean up the generated files.
2512         func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
2513
2514         # Transform the symbol file into the correct name.
2515         symfileobj="$output_objdir/${my_outputname}S.$objext"
2516         case $host in
2517         *cygwin* | *mingw* | *cegcc* )
2518           if test -f "$output_objdir/$my_outputname.def"; then
2519             compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2520             finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2521           else
2522             compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2523             finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2524           fi
2525           ;;
2526         *)
2527           compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2528           finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2529           ;;
2530         esac
2531         ;;
2532       *)
2533         func_fatal_error "unknown suffix for \`$my_dlsyms'"
2534         ;;
2535       esac
2536     else
2537       # We keep going just in case the user didn't refer to
2538       # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
2539       # really was required.
2540
2541       # Nullify the symbol file.
2542       compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
2543       finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
2544     fi
2545 }
2546
2547 # func_win32_libid arg
2548 # return the library type of file 'arg'
2549 #
2550 # Need a lot of goo to handle *both* DLLs and import libs
2551 # Has to be a shell function in order to 'eat' the argument
2552 # that is supplied when $file_magic_command is called.
2553 func_win32_libid ()
2554 {
2555   $opt_debug
2556   win32_libid_type="unknown"
2557   win32_fileres=`file -L $1 2>/dev/null`
2558   case $win32_fileres in
2559   *ar\ archive\ import\ library*) # definitely import
2560     win32_libid_type="x86 archive import"
2561     ;;
2562   *ar\ archive*) # could be an import, or static
2563     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
2564        $EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
2565       win32_nmres=`eval $NM -f posix -A $1 |
2566         $SED -n -e '
2567             1,100{
2568                 / I /{
2569                     s,.*,import,
2570                     p
2571                     q
2572                 }
2573             }'`
2574       case $win32_nmres in
2575       import*)  win32_libid_type="x86 archive import";;
2576       *)        win32_libid_type="x86 archive static";;
2577       esac
2578     fi
2579     ;;
2580   *DLL*)
2581     win32_libid_type="x86 DLL"
2582     ;;
2583   *executable*) # but shell scripts are "executable" too...
2584     case $win32_fileres in
2585     *MS\ Windows\ PE\ Intel*)
2586       win32_libid_type="x86 DLL"
2587       ;;
2588     esac
2589     ;;
2590   esac
2591   $ECHO "$win32_libid_type"
2592 }
2593
2594
2595
2596 # func_extract_an_archive dir oldlib
2597 func_extract_an_archive ()
2598 {
2599     $opt_debug
2600     f_ex_an_ar_dir="$1"; shift
2601     f_ex_an_ar_oldlib="$1"
2602     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
2603     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
2604      :
2605     else
2606       func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
2607     fi
2608 }
2609
2610
2611 # func_extract_archives gentop oldlib ...
2612 func_extract_archives ()
2613 {
2614     $opt_debug
2615     my_gentop="$1"; shift
2616     my_oldlibs=${1+"$@"}
2617     my_oldobjs=""
2618     my_xlib=""
2619     my_xabs=""
2620     my_xdir=""
2621
2622     for my_xlib in $my_oldlibs; do
2623       # Extract the objects.
2624       case $my_xlib in
2625         [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
2626         *) my_xabs=`pwd`"/$my_xlib" ;;
2627       esac
2628       func_basename "$my_xlib"
2629       my_xlib="$func_basename_result"
2630       my_xlib_u=$my_xlib
2631       while :; do
2632         case " $extracted_archives " in
2633         *" $my_xlib_u "*)
2634           func_arith $extracted_serial + 1
2635           extracted_serial=$func_arith_result
2636           my_xlib_u=lt$extracted_serial-$my_xlib ;;
2637         *) break ;;
2638         esac
2639       done
2640       extracted_archives="$extracted_archives $my_xlib_u"
2641       my_xdir="$my_gentop/$my_xlib_u"
2642
2643       func_mkdir_p "$my_xdir"
2644
2645       case $host in
2646       *-darwin*)
2647         func_verbose "Extracting $my_xabs"
2648         # Do not bother doing anything if just a dry run
2649         $opt_dry_run || {
2650           darwin_orig_dir=`pwd`
2651           cd $my_xdir || exit $?
2652           darwin_archive=$my_xabs
2653           darwin_curdir=`pwd`
2654           darwin_base_archive=`basename "$darwin_archive"`
2655           darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
2656           if test -n "$darwin_arches"; then
2657             darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
2658             darwin_arch=
2659             func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
2660             for darwin_arch in  $darwin_arches ; do
2661               func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2662               $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
2663               cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2664               func_extract_an_archive "`pwd`" "${darwin_base_archive}"
2665               cd "$darwin_curdir"
2666               $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
2667             done # $darwin_arches
2668             ## Okay now we've a bunch of thin objects, gotta fatten them up :)
2669             darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
2670             darwin_file=
2671             darwin_files=
2672             for darwin_file in $darwin_filelist; do
2673               darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
2674               $LIPO -create -output "$darwin_file" $darwin_files
2675             done # $darwin_filelist
2676             $RM -rf unfat-$$
2677             cd "$darwin_orig_dir"
2678           else
2679             cd $darwin_orig_dir
2680             func_extract_an_archive "$my_xdir" "$my_xabs"
2681           fi # $darwin_arches
2682         } # !$opt_dry_run
2683         ;;
2684       *)
2685         func_extract_an_archive "$my_xdir" "$my_xabs"
2686         ;;
2687       esac
2688       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
2689     done
2690
2691     func_extract_archives_result="$my_oldobjs"
2692 }
2693
2694
2695
2696 # func_emit_wrapper_part1 [arg=no]
2697 #
2698 # Emit the first part of a libtool wrapper script on stdout.
2699 # For more information, see the description associated with
2700 # func_emit_wrapper(), below.
2701 func_emit_wrapper_part1 ()
2702 {
2703         func_emit_wrapper_part1_arg1=no
2704         if test -n "$1" ; then
2705           func_emit_wrapper_part1_arg1=$1
2706         fi
2707
2708         $ECHO "\
2709 #! $SHELL
2710
2711 # $output - temporary wrapper script for $objdir/$outputname
2712 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
2713 #
2714 # The $output program cannot be directly executed until all the libtool
2715 # libraries that it depends on are installed.
2716 #
2717 # This wrapper script should never be moved out of the build directory.
2718 # If it is, it will not operate correctly.
2719
2720 # Sed substitution that helps us do robust quoting.  It backslashifies
2721 # metacharacters that are still active within double-quoted strings.
2722 Xsed='${SED} -e 1s/^X//'
2723 sed_quote_subst='$sed_quote_subst'
2724
2725 # Be Bourne compatible
2726 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
2727   emulate sh
2728   NULLCMD=:
2729   # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
2730   # is contrary to our usage.  Disable this feature.
2731   alias -g '\${1+\"\$@\"}'='\"\$@\"'
2732   setopt NO_GLOB_SUBST
2733 else
2734   case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
2735 fi
2736 BIN_SH=xpg4; export BIN_SH # for Tru64
2737 DUALCASE=1; export DUALCASE # for MKS sh
2738
2739 # The HP-UX ksh and POSIX shell print the target directory to stdout
2740 # if CDPATH is set.
2741 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
2742
2743 relink_command=\"$relink_command\"
2744
2745 # This environment variable determines our operation mode.
2746 if test \"\$libtool_install_magic\" = \"$magic\"; then
2747   # install mode needs the following variables:
2748   generated_by_libtool_version='$macro_version'
2749   notinst_deplibs='$notinst_deplibs'
2750 else
2751   # When we are sourced in execute mode, \$file and \$ECHO are already set.
2752   if test \"\$libtool_execute_magic\" != \"$magic\"; then
2753     ECHO=\"$qecho\"
2754     file=\"\$0\"
2755     # Make sure echo works.
2756     if test \"X\$1\" = X--no-reexec; then
2757       # Discard the --no-reexec flag, and continue.
2758       shift
2759     elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
2760       # Yippee, \$ECHO works!
2761       :
2762     else
2763       # Restart under the correct shell, and then maybe \$ECHO will work.
2764       exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
2765     fi
2766   fi\
2767 "
2768         $ECHO "\
2769
2770   # Find the directory that this script lives in.
2771   thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
2772   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
2773
2774   # Follow symbolic links until we get to the real thisdir.
2775   file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
2776   while test -n \"\$file\"; do
2777     destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
2778
2779     # If there was a directory component, then change thisdir.
2780     if test \"x\$destdir\" != \"x\$file\"; then
2781       case \"\$destdir\" in
2782       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
2783       *) thisdir=\"\$thisdir/\$destdir\" ;;
2784       esac
2785     fi
2786
2787     file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
2788     file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
2789   done
2790 "
2791 }
2792 # end: func_emit_wrapper_part1
2793
2794 # func_emit_wrapper_part2 [arg=no]
2795 #
2796 # Emit the second part of a libtool wrapper script on stdout.
2797 # For more information, see the description associated with
2798 # func_emit_wrapper(), below.
2799 func_emit_wrapper_part2 ()
2800 {
2801         func_emit_wrapper_part2_arg1=no
2802         if test -n "$1" ; then
2803           func_emit_wrapper_part2_arg1=$1
2804         fi
2805
2806         $ECHO "\
2807
2808   # Usually 'no', except on cygwin/mingw when embedded into
2809   # the cwrapper.
2810   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
2811   if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
2812     # special case for '.'
2813     if test \"\$thisdir\" = \".\"; then
2814       thisdir=\`pwd\`
2815     fi
2816     # remove .libs from thisdir
2817     case \"\$thisdir\" in
2818     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
2819     $objdir )   thisdir=. ;;
2820     esac
2821   fi
2822
2823   # Try to get the absolute directory name.
2824   absdir=\`cd \"\$thisdir\" && pwd\`
2825   test -n \"\$absdir\" && thisdir=\"\$absdir\"
2826 "
2827
2828         if test "$fast_install" = yes; then
2829           $ECHO "\
2830   program=lt-'$outputname'$exeext
2831   progdir=\"\$thisdir/$objdir\"
2832
2833   if test ! -f \"\$progdir/\$program\" ||
2834      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
2835        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
2836
2837     file=\"\$\$-\$program\"
2838
2839     if test ! -d \"\$progdir\"; then
2840       $MKDIR \"\$progdir\"
2841     else
2842       $RM \"\$progdir/\$file\"
2843     fi"
2844
2845           $ECHO "\
2846
2847     # relink executable if necessary
2848     if test -n \"\$relink_command\"; then
2849       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
2850       else
2851         $ECHO \"\$relink_command_output\" >&2
2852         $RM \"\$progdir/\$file\"
2853         exit 1
2854       fi
2855     fi
2856
2857     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
2858     { $RM \"\$progdir/\$program\";
2859       $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
2860     $RM \"\$progdir/\$file\"
2861   fi"
2862         else
2863           $ECHO "\
2864   program='$outputname'
2865   progdir=\"\$thisdir/$objdir\"
2866 "
2867         fi
2868
2869         $ECHO "\
2870
2871   if test -f \"\$progdir/\$program\"; then"
2872
2873         # Export our shlibpath_var if we have one.
2874         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
2875           $ECHO "\
2876     # Add our own library path to $shlibpath_var
2877     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
2878
2879     # Some systems cannot cope with colon-terminated $shlibpath_var
2880     # The second colon is a workaround for a bug in BeOS R4 sed
2881     $shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
2882
2883     export $shlibpath_var
2884 "
2885         fi
2886
2887         # fixup the dll searchpath if we need to.
2888         if test -n "$dllsearchpath"; then
2889           $ECHO "\
2890     # Add the dll search path components to the executable PATH
2891     PATH=$dllsearchpath:\$PATH
2892 "
2893         fi
2894
2895         $ECHO "\
2896     if test \"\$libtool_execute_magic\" != \"$magic\"; then
2897       # Run the actual program with our arguments.
2898 "
2899         case $host in
2900         # Backslashes separate directories on plain windows
2901         *-*-mingw | *-*-os2* | *-cegcc*)
2902           $ECHO "\
2903       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
2904 "
2905           ;;
2906
2907         *)
2908           $ECHO "\
2909       exec \"\$progdir/\$program\" \${1+\"\$@\"}
2910 "
2911           ;;
2912         esac
2913         $ECHO "\
2914       \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
2915       exit 1
2916     fi
2917   else
2918     # The program doesn't exist.
2919     \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
2920     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
2921     $ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
2922     exit 1
2923   fi
2924 fi\
2925 "
2926 }
2927 # end: func_emit_wrapper_part2
2928
2929
2930 # func_emit_wrapper [arg=no]
2931 #
2932 # Emit a libtool wrapper script on stdout.
2933 # Don't directly open a file because we may want to
2934 # incorporate the script contents within a cygwin/mingw
2935 # wrapper executable.  Must ONLY be called from within
2936 # func_mode_link because it depends on a number of variables
2937 # set therein.
2938 #
2939 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
2940 # variable will take.  If 'yes', then the emitted script
2941 # will assume that the directory in which it is stored is
2942 # the $objdir directory.  This is a cygwin/mingw-specific
2943 # behavior.
2944 func_emit_wrapper ()
2945 {
2946         func_emit_wrapper_arg1=no
2947         if test -n "$1" ; then
2948           func_emit_wrapper_arg1=$1
2949         fi
2950
2951         # split this up so that func_emit_cwrapperexe_src
2952         # can call each part independently.
2953         func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"
2954         func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"
2955 }
2956
2957
2958 # func_to_host_path arg
2959 #
2960 # Convert paths to host format when used with build tools.
2961 # Intended for use with "native" mingw (where libtool itself
2962 # is running under the msys shell), or in the following cross-
2963 # build environments:
2964 #    $build          $host
2965 #    mingw (msys)    mingw  [e.g. native]
2966 #    cygwin          mingw
2967 #    *nix + wine     mingw
2968 # where wine is equipped with the `winepath' executable.
2969 # In the native mingw case, the (msys) shell automatically
2970 # converts paths for any non-msys applications it launches,
2971 # but that facility isn't available from inside the cwrapper.
2972 # Similar accommodations are necessary for $host mingw and
2973 # $build cygwin.  Calling this function does no harm for other
2974 # $host/$build combinations not listed above.
2975 #
2976 # ARG is the path (on $build) that should be converted to
2977 # the proper representation for $host. The result is stored
2978 # in $func_to_host_path_result.
2979 func_to_host_path ()
2980 {
2981   func_to_host_path_result="$1"
2982   if test -n "$1" ; then
2983     case $host in
2984       *mingw* )
2985         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
2986         case $build in
2987           *mingw* ) # actually, msys
2988             # awkward: cmd appends spaces to result
2989             lt_sed_strip_trailing_spaces="s/[ ]*\$//"
2990             func_to_host_path_tmp1=`( cmd //c echo "$1" |\
2991               $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
2992             func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
2993               $SED -e "$lt_sed_naive_backslashify"`
2994             ;;
2995           *cygwin* )
2996             func_to_host_path_tmp1=`cygpath -w "$1"`
2997             func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
2998               $SED -e "$lt_sed_naive_backslashify"`
2999             ;;
3000           * )
3001             # Unfortunately, winepath does not exit with a non-zero
3002             # error code, so we are forced to check the contents of
3003             # stdout. On the other hand, if the command is not
3004             # found, the shell will set an exit code of 127 and print
3005             # *an error message* to stdout. So we must check for both
3006             # error code of zero AND non-empty stdout, which explains
3007             # the odd construction:
3008             func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
3009             if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
3010               func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3011                 $SED -e "$lt_sed_naive_backslashify"`
3012             else
3013               # Allow warning below.
3014               func_to_host_path_result=""
3015             fi
3016             ;;
3017         esac
3018         if test -z "$func_to_host_path_result" ; then
3019           func_error "Could not determine host path corresponding to"
3020           func_error "  '$1'"
3021           func_error "Continuing, but uninstalled executables may not work."
3022           # Fallback:
3023           func_to_host_path_result="$1"
3024         fi
3025         ;;
3026     esac
3027   fi
3028 }
3029 # end: func_to_host_path
3030
3031 # func_to_host_pathlist arg
3032 #
3033 # Convert pathlists to host format when used with build tools.
3034 # See func_to_host_path(), above. This function supports the
3035 # following $build/$host combinations (but does no harm for
3036 # combinations not listed here):
3037 #    $build          $host
3038 #    mingw (msys)    mingw  [e.g. native]
3039 #    cygwin          mingw
3040 #    *nix + wine     mingw
3041 #
3042 # Path separators are also converted from $build format to
3043 # $host format. If ARG begins or ends with a path separator
3044 # character, it is preserved (but converted to $host format)
3045 # on output.
3046 #
3047 # ARG is a pathlist (on $build) that should be converted to
3048 # the proper representation on $host. The result is stored
3049 # in $func_to_host_pathlist_result.
3050 func_to_host_pathlist ()
3051 {
3052   func_to_host_pathlist_result="$1"
3053   if test -n "$1" ; then
3054     case $host in
3055       *mingw* )
3056         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3057         # Remove leading and trailing path separator characters from
3058         # ARG. msys behavior is inconsistent here, cygpath turns them
3059         # into '.;' and ';.', and winepath ignores them completely.
3060         func_to_host_pathlist_tmp2="$1"
3061         # Once set for this call, this variable should not be
3062         # reassigned. It is used in tha fallback case.
3063         func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\
3064           $SED -e 's|^:*||' -e 's|:*$||'`
3065         case $build in
3066           *mingw* ) # Actually, msys.
3067             # Awkward: cmd appends spaces to result.
3068             lt_sed_strip_trailing_spaces="s/[ ]*\$//"
3069             func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\
3070               $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
3071             func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3072               $SED -e "$lt_sed_naive_backslashify"`
3073             ;;
3074           *cygwin* )
3075             func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`
3076             func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3077               $SED -e "$lt_sed_naive_backslashify"`
3078             ;;
3079           * )
3080             # unfortunately, winepath doesn't convert pathlists
3081             func_to_host_pathlist_result=""
3082             func_to_host_pathlist_oldIFS=$IFS
3083             IFS=:
3084             for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
3085               IFS=$func_to_host_pathlist_oldIFS
3086               if test -n "$func_to_host_pathlist_f" ; then
3087                 func_to_host_path "$func_to_host_pathlist_f"
3088                 if test -n "$func_to_host_path_result" ; then
3089                   if test -z "$func_to_host_pathlist_result" ; then
3090                     func_to_host_pathlist_result="$func_to_host_path_result"
3091                   else
3092                     func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"
3093                   fi
3094                 fi
3095               fi
3096               IFS=:
3097             done
3098             IFS=$func_to_host_pathlist_oldIFS
3099             ;;
3100         esac
3101         if test -z "$func_to_host_pathlist_result" ; then
3102           func_error "Could not determine the host path(s) corresponding to"
3103           func_error "  '$1'"
3104           func_error "Continuing, but uninstalled executables may not work."
3105           # Fallback. This may break if $1 contains DOS-style drive
3106           # specifications. The fix is not to complicate the expression
3107           # below, but for the user to provide a working wine installation
3108           # with winepath so that path translation in the cross-to-mingw
3109           # case works properly.
3110           lt_replace_pathsep_nix_to_dos="s|:|;|g"
3111           func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
3112             $SED -e "$lt_replace_pathsep_nix_to_dos"`
3113         fi
3114         # Now, add the leading and trailing path separators back
3115         case "$1" in
3116           :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
3117             ;;
3118         esac
3119         case "$1" in
3120           *: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"
3121             ;;
3122         esac
3123         ;;
3124     esac
3125   fi
3126 }
3127 # end: func_to_host_pathlist
3128
3129 # func_emit_cwrapperexe_src
3130 # emit the source code for a wrapper executable on stdout
3131 # Must ONLY be called from within func_mode_link because
3132 # it depends on a number of variable set therein.
3133 func_emit_cwrapperexe_src ()
3134 {
3135         cat <<EOF
3136
3137 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
3138    Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3139
3140    The $output program cannot be directly executed until all the libtool
3141    libraries that it depends on are installed.
3142
3143    This wrapper executable should never be moved out of the build directory.
3144    If it is, it will not operate correctly.
3145
3146    Currently, it simply execs the wrapper *script* "$SHELL $output",
3147    but could eventually absorb all of the scripts functionality and
3148    exec $objdir/$outputname directly.
3149 */
3150 EOF
3151             cat <<"EOF"
3152 #include <stdio.h>
3153 #include <stdlib.h>
3154 #ifdef _MSC_VER
3155 # include <direct.h>
3156 # include <process.h>
3157 # include <io.h>
3158 # define setmode _setmode
3159 #else
3160 # include <unistd.h>
3161 # include <stdint.h>
3162 # ifdef __CYGWIN__
3163 #  include <io.h>
3164 #  define HAVE_SETENV
3165 #  ifdef __STRICT_ANSI__
3166 char *realpath (const char *, char *);
3167 int putenv (char *);
3168 int setenv (const char *, const char *, int);
3169 #  endif
3170 # endif
3171 #endif
3172 #include <malloc.h>
3173 #include <stdarg.h>
3174 #include <assert.h>
3175 #include <string.h>
3176 #include <ctype.h>
3177 #include <errno.h>
3178 #include <fcntl.h>
3179 #include <sys/stat.h>
3180
3181 #if defined(PATH_MAX)
3182 # define LT_PATHMAX PATH_MAX
3183 #elif defined(MAXPATHLEN)
3184 # define LT_PATHMAX MAXPATHLEN
3185 #else
3186 # define LT_PATHMAX 1024
3187 #endif
3188
3189 #ifndef S_IXOTH
3190 # define S_IXOTH 0
3191 #endif
3192 #ifndef S_IXGRP
3193 # define S_IXGRP 0
3194 #endif
3195
3196 #ifdef _MSC_VER
3197 # define S_IXUSR _S_IEXEC
3198 # define stat _stat
3199 # ifndef _INTPTR_T_DEFINED
3200 #  define intptr_t int
3201 # endif
3202 #endif
3203
3204 #ifndef DIR_SEPARATOR
3205 # define DIR_SEPARATOR '/'
3206 # define PATH_SEPARATOR ':'
3207 #endif
3208
3209 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
3210   defined (__OS2__)
3211 # define HAVE_DOS_BASED_FILE_SYSTEM
3212 # define FOPEN_WB "wb"
3213 # ifndef DIR_SEPARATOR_2
3214 #  define DIR_SEPARATOR_2 '\\'
3215 # endif
3216 # ifndef PATH_SEPARATOR_2
3217 #  define PATH_SEPARATOR_2 ';'
3218 # endif
3219 #endif
3220
3221 #ifndef DIR_SEPARATOR_2
3222 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3223 #else /* DIR_SEPARATOR_2 */
3224 # define IS_DIR_SEPARATOR(ch) \
3225         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
3226 #endif /* DIR_SEPARATOR_2 */
3227
3228 #ifndef PATH_SEPARATOR_2
3229 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3230 #else /* PATH_SEPARATOR_2 */
3231 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3232 #endif /* PATH_SEPARATOR_2 */
3233
3234 #ifdef __CYGWIN__
3235 # define FOPEN_WB "wb"
3236 #endif
3237
3238 #ifndef FOPEN_WB
3239 # define FOPEN_WB "w"
3240 #endif
3241 #ifndef _O_BINARY
3242 # define _O_BINARY 0
3243 #endif
3244
3245 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
3246 #define XFREE(stale) do { \
3247   if (stale) { free ((void *) stale); stale = 0; } \
3248 } while (0)
3249
3250 #undef LTWRAPPER_DEBUGPRINTF
3251 #if defined DEBUGWRAPPER
3252 # define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3253 static void
3254 ltwrapper_debugprintf (const char *fmt, ...)
3255 {
3256     va_list args;
3257     va_start (args, fmt);
3258     (void) vfprintf (stderr, fmt, args);
3259     va_end (args);
3260 }
3261 #else
3262 # define LTWRAPPER_DEBUGPRINTF(args)
3263 #endif
3264
3265 const char *program_name = NULL;
3266
3267 void *xmalloc (size_t num);
3268 char *xstrdup (const char *string);
3269 const char *base_name (const char *name);
3270 char *find_executable (const char *wrapper);
3271 char *chase_symlinks (const char *pathspec);
3272 int make_executable (const char *path);
3273 int check_executable (const char *path);
3274 char *strendzap (char *str, const char *pat);
3275 void lt_fatal (const char *message, ...);
3276 void lt_setenv (const char *name, const char *value);
3277 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
3278 void lt_opt_process_env_set (const char *arg);
3279 void lt_opt_process_env_prepend (const char *arg);
3280 void lt_opt_process_env_append (const char *arg);
3281 int lt_split_name_value (const char *arg, char** name, char** value);
3282 void lt_update_exe_path (const char *name, const char *value);
3283 void lt_update_lib_path (const char *name, const char *value);
3284
3285 static const char *script_text_part1 =
3286 EOF
3287
3288             func_emit_wrapper_part1 yes |
3289                 $SED -e 's/\([\\"]\)/\\\1/g' \
3290                      -e 's/^/  "/' -e 's/$/\\n"/'
3291             echo ";"
3292             cat <<EOF
3293
3294 static const char *script_text_part2 =
3295 EOF
3296             func_emit_wrapper_part2 yes |
3297                 $SED -e 's/\([\\"]\)/\\\1/g' \
3298                      -e 's/^/  "/' -e 's/$/\\n"/'
3299             echo ";"
3300
3301             cat <<EOF
3302 const char * MAGIC_EXE = "$magic_exe";
3303 const char * LIB_PATH_VARNAME = "$shlibpath_var";
3304 EOF
3305
3306             if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3307               func_to_host_pathlist "$temp_rpath"
3308               cat <<EOF
3309 const char * LIB_PATH_VALUE   = "$func_to_host_pathlist_result";
3310 EOF
3311             else
3312               cat <<"EOF"
3313 const char * LIB_PATH_VALUE   = "";
3314 EOF
3315             fi
3316
3317             if test -n "$dllsearchpath"; then
3318               func_to_host_pathlist "$dllsearchpath:"
3319               cat <<EOF
3320 const char * EXE_PATH_VARNAME = "PATH";
3321 const char * EXE_PATH_VALUE   = "$func_to_host_pathlist_result";
3322 EOF
3323             else
3324               cat <<"EOF"
3325 const char * EXE_PATH_VARNAME = "";
3326 const char * EXE_PATH_VALUE   = "";
3327 EOF
3328             fi
3329
3330             if test "$fast_install" = yes; then
3331               cat <<EOF
3332 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
3333 EOF
3334             else
3335               cat <<EOF
3336 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
3337 EOF
3338             fi
3339
3340
3341             cat <<"EOF"
3342
3343 #define LTWRAPPER_OPTION_PREFIX         "--lt-"
3344 #define LTWRAPPER_OPTION_PREFIX_LENGTH  5
3345
3346 static const size_t opt_prefix_len         = LTWRAPPER_OPTION_PREFIX_LENGTH;
3347 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3348
3349 static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
3350
3351 static const size_t env_set_opt_len     = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;
3352 static const char *env_set_opt          = LTWRAPPER_OPTION_PREFIX "env-set";
3353   /* argument is putenv-style "foo=bar", value of foo is set to bar */
3354
3355 static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;
3356 static const char *env_prepend_opt      = LTWRAPPER_OPTION_PREFIX "env-prepend";
3357   /* argument is putenv-style "foo=bar", new value of foo is bar${foo} */
3358
3359 static const size_t env_append_opt_len  = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;
3360 static const char *env_append_opt       = LTWRAPPER_OPTION_PREFIX "env-append";
3361   /* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */
3362
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