ltmain.sh

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