release/src/router/lzo/autoconf/ltmain.sh

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