ltmain.sh

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