release/src/router/cyassl/ltmain.sh

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