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
   5 # 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 # Check that we have a working $echo.
  28 if test "X$1" = X--no-reexec; then
  29   # Discard the --no-reexec flag, and continue.
  30   shift
  31 elif test "X$1" = X--fallback-echo; then
  32   # Avoid inline document here, it may be left over
  33   :
  34 elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
  35   # Yippee, $echo works!
  36   :
  37 else
  38   # Restart under the correct shell, and then maybe $echo will work.
  39   exec $SHELL "$0" --no-reexec ${1+"$@"}
  40 fi
  41
  42 if test "X$1" = X--fallback-echo; then
  43   # used as fallback echo
  44   shift
  45   cat <<EOF
  46 $*
  47 EOF
  48   exit 0
  49 fi
  50
  51 # The name of this program.
  52 progname=`$echo "$0" | ${SED} 's%^.*/%%'`
  53 modename="$progname"
  54
  55 # Constants.
  56 PROGRAM=ltmain.sh
  57 PACKAGE=libtool
  58 VERSION=1.4.3
  59 TIMESTAMP=" (1.922.2.111 2002/10/23 02:54:36)"
  60
  61 default_mode=
  62 help="Try \`$progname --help' for more information."
  63 magic="%%%MAGIC variable%%%"
  64 mkdir="mkdir"
  65 mv="mv -f"
  66 rm="rm -f"
  67
  68 # Sed substitution that helps us do robust quoting.  It backslashifies
  69 # metacharacters that are still active within double-quoted strings.
  70 Xsed="${SED}"' -e 1s/^X//'
  71 sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
  72 # test EBCDIC or ASCII
  73 case `echo A|od -x` in
  74  *[Cc]1*) # EBCDIC based system
  75   SP2NL="tr '\100' '\n'"
  76   NL2SP="tr '\r\n' '\100\100'"
  77   ;;
  78  *) # Assume ASCII based system
  79   SP2NL="tr '\040' '\012'"
  80   NL2SP="tr '\015\012' '\040\040'"
  81   ;;
  82 esac
  83
  84 # NLS nuisances.
  85 # Only set LANG and LC_ALL to C if already set.
  86 # These must not be set unconditionally because not all systems understand
  87 # e.g. LANG=C (notably SCO).
  88 # We save the old values to restore during execute mode.
  89 if test "${LC_ALL+set}" = set; then
  90   save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
  91 fi
  92 if test "${LANG+set}" = set; then
  93   save_LANG="$LANG"; LANG=C; export LANG
  94 fi
  95
  96 # Make sure IFS has a sensible default
  97 : ${IFS="       "}
  98
  99 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
 100   echo "$modename: not configured to build any kind of library" 1>&2
 101   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
 102   exit 1
 103 fi
 104
 105 # Global variables.
 106 mode=$default_mode
 107 nonopt=
 108 prev=
 109 prevopt=
 110 run=
 111 show="$echo"
 112 show_help=
 113 execute_dlfiles=
 114 lo2o="s/\\.lo\$/.${objext}/"
 115 o2lo="s/\\.${objext}\$/.lo/"
 116
 117 # Parse our command line options once, thoroughly.
 118 while test $# -gt 0
 119 do
 120   arg="$1"
 121   shift
 122
 123   case $arg in
 124   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
 125   *) optarg= ;;
 126   esac
 127
 128   # If the previous option needs an argument, assign it.
 129   if test -n "$prev"; then
 130     case $prev in
 131     execute_dlfiles)
 132       execute_dlfiles="$execute_dlfiles $arg"
 133       ;;
 134     *)
 135       eval "$prev=\$arg"
 136       ;;
 137     esac
 138
 139     prev=
 140     prevopt=
 141     continue
 142   fi
 143
 144   # Have we seen a non-optional argument yet?
 145   case $arg in
 146   --help)
 147     show_help=yes
 148     ;;
 149
 150   --version)
 151     echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
 152     exit 0
 153     ;;
 154
 155   --config)
 156     ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $0
 157     exit 0
 158     ;;
 159
 160   --debug)
 161     echo "$progname: enabling shell trace mode"
 162     set -x
 163     ;;
 164
 165   --dry-run | -n)
 166     run=:
 167     ;;
 168
 169   --features)
 170     echo "host: $host"
 171     if test "$build_libtool_libs" = yes; then
 172       echo "enable shared libraries"
 173     else
 174       echo "disable shared libraries"
 175     fi
 176     if test "$build_old_libs" = yes; then
 177       echo "enable static libraries"
 178     else
 179       echo "disable static libraries"
 180     fi
 181     exit 0
 182     ;;
 183
 184   --finish) mode="finish" ;;
 185
 186   --mode) prevopt="--mode" prev=mode ;;
 187   --mode=*) mode="$optarg" ;;
 188
 189   --preserve-dup-deps) duplicate_deps="yes" ;;
 190
 191   --quiet | --silent)
 192     show=:
 193     ;;
 194
 195   -dlopen)
 196     prevopt="-dlopen"
 197     prev=execute_dlfiles
 198     ;;
 199
 200   -*)
 201     $echo "$modename: unrecognized option \`$arg'" 1>&2
 202     $echo "$help" 1>&2
 203     exit 1
 204     ;;
 205
 206   *)
 207     nonopt="$arg"
 208     break
 209     ;;
 210   esac
 211 done
 212
 213 if test -n "$prevopt"; then
 214   $echo "$modename: option \`$prevopt' requires an argument" 1>&2
 215   $echo "$help" 1>&2
 216   exit 1
 217 fi
 218
 219 # If this variable is set in any of the actions, the command in it
 220 # will be execed at the end.  This prevents here-documents from being
 221 # left over by shells.
 222 exec_cmd=
 223
 224 if test -z "$show_help"; then
 225
 226   # Infer the operation mode.
 227   if test -z "$mode"; then
 228     case $nonopt in
 229     *cc | *++ | gcc* | *-gcc* | g++* | xlc*)
 230       mode=link
 231       for arg
 232       do
 233         case $arg in
 234         -c)
 235            mode=compile
 236            break
 237            ;;
 238         esac
 239       done
 240       ;;
 241     *db | *dbx | *strace | *truss)
 242       mode=execute
 243       ;;
 244     *install*|cp|mv)
 245       mode=install
 246       ;;
 247     *rm)
 248       mode=uninstall
 249       ;;
 250     *)
 251       # If we have no mode, but dlfiles were specified, then do execute mode.
 252       test -n "$execute_dlfiles" && mode=execute
 253
 254       # Just use the default operation mode.
 255       if test -z "$mode"; then
 256         if test -n "$nonopt"; then
 257           $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
 258         else
 259           $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
 260         fi
 261       fi
 262       ;;
 263     esac
 264   fi
 265
 266   # Only execute mode is allowed to have -dlopen flags.
 267   if test -n "$execute_dlfiles" && test "$mode" != execute; then
 268     $echo "$modename: unrecognized option \`-dlopen'" 1>&2
 269     $echo "$help" 1>&2
 270     exit 1
 271   fi
 272
 273   # Change the help message to a mode-specific one.
 274   generic_help="$help"
 275   help="Try \`$modename --help --mode=$mode' for more information."
 276
 277   # These modes are in order of execution frequency so that they run quickly.
 278   case $mode in
 279   # libtool compile mode
 280   compile)
 281     modename="$modename: compile"
 282     # Get the compilation command and the source file.
 283     base_compile=
 284     prev=
 285     lastarg=
 286     srcfile="$nonopt"
 287     suppress_output=
 288
 289     user_target=no
 290     for arg
 291     do
 292       case $prev in
 293       "") ;;
 294       xcompiler)
 295         # Aesthetically quote the previous argument.
 296         prev=
 297         lastarg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
 298
 299         case $arg in
 300         # Double-quote args containing other shell metacharacters.
 301         # Many Bourne shells cannot handle close brackets correctly
 302         # in scan sets, so we specify it separately.
 303         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
 304           arg="\"$arg\""
 305           ;;
 306         esac
 307
 308         # Add the previous argument to base_compile.
 309         if test -z "$base_compile"; then
 310           base_compile="$lastarg"
 311         else
 312           base_compile="$base_compile $lastarg"
 313         fi
 314         continue
 315         ;;
 316       esac
 317
 318       # Accept any command-line options.
 319       case $arg in
 320       -o)
 321         if test "$user_target" != "no"; then
 322           $echo "$modename: you cannot specify \`-o' more than once" 1>&2
 323           exit 1
 324         fi
 325         user_target=next
 326         ;;
 327
 328       -static)
 329         build_old_libs=yes
 330         continue
 331         ;;
 332
 333       -prefer-pic)
 334         pic_mode=yes
 335         continue
 336         ;;
 337
 338       -prefer-non-pic)
 339         pic_mode=no
 340         continue
 341         ;;
 342
 343       -Xcompiler)
 344         prev=xcompiler
 345         continue
 346         ;;
 347
 348       -Wc,*)
 349         args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
 350         lastarg=
 351         save_ifs="$IFS"; IFS=','
 352         for arg in $args; do
 353           IFS="$save_ifs"
 354
 355           # Double-quote args containing other shell metacharacters.
 356           # Many Bourne shells cannot handle close brackets correctly
 357           # in scan sets, so we specify it separately.
 358           case $arg in
 359             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
 360             arg="\"$arg\""
 361             ;;
 362           esac
 363           lastarg="$lastarg $arg"
 364         done
 365         IFS="$save_ifs"
 366         lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
 367
 368         # Add the arguments to base_compile.
 369         if test -z "$base_compile"; then
 370           base_compile="$lastarg"
 371         else
 372           base_compile="$base_compile $lastarg"
 373         fi
 374         continue
 375         ;;
 376       esac
 377
 378       case $user_target in
 379       next)
 380         # The next one is the -o target name
 381         user_target=yes
 382         continue
 383         ;;
 384       yes)
 385         # We got the output file
 386         user_target=set
 387         libobj="$arg"
 388         continue
 389         ;;
 390       esac
 391
 392       # Accept the current argument as the source file.
 393       lastarg="$srcfile"
 394       srcfile="$arg"
 395
 396       # Aesthetically quote the previous argument.
 397
 398       # Backslashify any backslashes, double quotes, and dollar signs.
 399       # These are the only characters that are still specially
 400       # interpreted inside of double-quoted scrings.
 401       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
 402
 403       # Double-quote args containing other shell metacharacters.
 404       # Many Bourne shells cannot handle close brackets correctly
 405       # in scan sets, so we specify it separately.
 406       case $lastarg in
 407       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 408         lastarg="\"$lastarg\""
 409         ;;
 410       esac
 411
 412       # Add the previous argument to base_compile.
 413       if test -z "$base_compile"; then
 414         base_compile="$lastarg"
 415       else
 416         base_compile="$base_compile $lastarg"
 417       fi
 418     done
 419
 420     case $user_target in
 421     set)
 422       ;;
 423     no)
 424       # Get the name of the library object.
 425       libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
 426       ;;
 427     *)
 428       $echo "$modename: you must specify a target with \`-o'" 1>&2
 429       exit 1
 430       ;;
 431     esac
 432
 433     # Recognize several different file suffixes.
 434     # If the user specifies -o file.o, it is replaced with file.lo
 435     xform='[cCFSfmso]'
 436     case $libobj in
 437     *.ada) xform=ada ;;
 438     *.adb) xform=adb ;;
 439     *.ads) xform=ads ;;
 440     *.asm) xform=asm ;;
 441     *.c++) xform=c++ ;;
 442     *.cc) xform=cc ;;
 443     *.cpp) xform=cpp ;;
 444     *.cxx) xform=cxx ;;
 445     *.f90) xform=f90 ;;
 446     *.for) xform=for ;;
 447     esac
 448
 449     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
 450
 451     case $libobj in
 452     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
 453     *)
 454       $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
 455       exit 1
 456       ;;
 457     esac
 458
 459     if test -z "$base_compile"; then
 460       $echo "$modename: you must specify a compilation command" 1>&2
 461       $echo "$help" 1>&2
 462       exit 1
 463     fi
 464
 465     # Delete any leftover library objects.
 466     if test "$build_old_libs" = yes; then
 467       removelist="$obj $libobj"
 468     else
 469       removelist="$libobj"
 470     fi
 471
 472     $run $rm $removelist
 473     trap "$run $rm $removelist; exit 1" 1 2 15
 474
 475     # On Cygwin there's no "real" PIC flag so we must build both object types
 476     case $host_os in
 477     cygwin* | mingw* | pw32* | os2*)
 478       pic_mode=default
 479       ;;
 480     esac
 481     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
 482       # non-PIC code in shared libraries is not supported
 483       pic_mode=default
 484     fi
 485
 486     # Calculate the filename of the output object if compiler does
 487     # not support -o with -c
 488     if test "$compiler_c_o" = no; then
 489       output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
 490       lockfile="$output_obj.lock"
 491       removelist="$removelist $output_obj $lockfile"
 492       trap "$run $rm $removelist; exit 1" 1 2 15
 493     else
 494       need_locks=no
 495       lockfile=
 496     fi
 497
 498     # Lock this critical section if it is needed
 499     # We use this script file to make the link, it avoids creating a new file
 500     if test "$need_locks" = yes; then
 501       until $run ln "$0" "$lockfile" 2>/dev/null; do
 502         $show "Waiting for $lockfile to be removed"
 503         sleep 2
 504       done
 505     elif test "$need_locks" = warn; then
 506       if test -f "$lockfile"; then
 507         echo "\
 508 *** ERROR, $lockfile exists and contains:
 509 `cat $lockfile 2>/dev/null`
 510
 511 This indicates that another process is trying to use the same
 512 temporary object file, and libtool could not work around it because
 513 your compiler does not support \`-c' and \`-o' together.  If you
 514 repeat this compilation, it may succeed, by chance, but you had better
 515 avoid parallel builds (make -j) in this platform, or get a better
 516 compiler."
 517
 518         $run $rm $removelist
 519         exit 1
 520       fi
 521       echo $srcfile > "$lockfile"
 522     fi
 523
 524     if test -n "$fix_srcfile_path"; then
 525       eval srcfile=\"$fix_srcfile_path\"
 526     fi
 527
 528     # Only build a PIC object if we are building libtool libraries.
 529     if test "$build_libtool_libs" = yes; then
 530       # Without this assignment, base_compile gets emptied.
 531       fbsd_hideous_sh_bug=$base_compile
 532
 533       if test "$pic_mode" != no; then
 534         # All platforms use -DPIC, to notify preprocessed assembler code.
 535         command="$base_compile $srcfile $pic_flag -DPIC"
 536       else
 537         # Don't build PIC code
 538         command="$base_compile $srcfile"
 539       fi
 540       if test "$build_old_libs" = yes; then
 541         lo_libobj="$libobj"
 542         dir=`$echo "X$libobj" | $Xsed -e 's%/[^/]*$%%'`
 543         if test "X$dir" = "X$libobj"; then
 544           dir="$objdir"
 545         else
 546           dir="$dir/$objdir"
 547         fi
 548         libobj="$dir/"`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`
 549
 550         if test -d "$dir"; then
 551           $show "$rm $libobj"
 552           $run $rm $libobj
 553         else
 554           $show "$mkdir $dir"
 555           $run $mkdir $dir
 556           status=$?
 557           if test $status -ne 0 && test ! -d $dir; then
 558             exit $status
 559           fi
 560         fi
 561       fi
 562       if test "$compiler_o_lo" = yes; then
 563         output_obj="$libobj"
 564         command="$command -o $output_obj"
 565       elif test "$compiler_c_o" = yes; then
 566         output_obj="$obj"
 567         command="$command -o $output_obj"
 568       fi
 569
 570       $run $rm "$output_obj"
 571       $show "$command"
 572       if $run eval "$command"; then :
 573       else
 574         test -n "$output_obj" && $run $rm $removelist
 575         exit 1
 576       fi
 577
 578       if test "$need_locks" = warn &&
 579          test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
 580         echo "\
 581 *** ERROR, $lockfile contains:
 582 `cat $lockfile 2>/dev/null`
 583
 584 but it should contain:
 585 $srcfile
 586
 587 This indicates that another process is trying to use the same
 588 temporary object file, and libtool could not work around it because
 589 your compiler does not support \`-c' and \`-o' together.  If you
 590 repeat this compilation, it may succeed, by chance, but you had better
 591 avoid parallel builds (make -j) in this platform, or get a better
 592 compiler."
 593
 594         $run $rm $removelist
 595         exit 1
 596       fi
 597
 598       # Just move the object if needed, then go on to compile the next one
 599       if test x"$output_obj" != x"$libobj"; then
 600         $show "$mv $output_obj $libobj"
 601         if $run $mv $output_obj $libobj; then :
 602         else
 603           error=$?
 604           $run $rm $removelist
 605           exit $error
 606         fi
 607       fi
 608
 609       # If we have no pic_flag, then copy the object into place and finish.
 610       if (test -z "$pic_flag" || test "$pic_mode" != default) &&
 611          test "$build_old_libs" = yes; then
 612         # Rename the .lo from within objdir to obj
 613         if test -f $obj; then
 614           $show $rm $obj
 615           $run $rm $obj
 616         fi
 617
 618         $show "$mv $libobj $obj"
 619         if $run $mv $libobj $obj; then :
 620         else
 621           error=$?
 622           $run $rm $removelist
 623           exit $error
 624         fi
 625
 626         xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
 627         if test "X$xdir" = "X$obj"; then
 628           xdir="."
 629         else
 630           xdir="$xdir"
 631         fi
 632         baseobj=`$echo "X$obj" | $Xsed -e "s%.*/%%"`
 633         libobj=`$echo "X$baseobj" | $Xsed -e "$o2lo"`
 634         # Now arrange that obj and lo_libobj become the same file
 635         $show "(cd $xdir && $LN_S $baseobj $libobj)"
 636         if $run eval '(cd $xdir && $LN_S $baseobj $libobj)'; then
 637           # Unlock the critical section if it was locked
 638           if test "$need_locks" != no; then
 639             $run $rm "$lockfile"
 640           fi
 641           exit 0
 642         else
 643           error=$?
 644           $run $rm $removelist
 645           exit $error
 646         fi
 647       fi
 648
 649       # Allow error messages only from the first compilation.
 650       suppress_output=' >/dev/null 2>&1'
 651     fi
 652
 653     # Only build a position-dependent object if we build old libraries.
 654     if test "$build_old_libs" = yes; then
 655       if test "$pic_mode" != yes; then
 656         # Don't build PIC code
 657         command="$base_compile $srcfile"
 658       else
 659         # All platforms use -DPIC, to notify preprocessed assembler code.
 660         command="$base_compile $srcfile $pic_flag -DPIC"
 661       fi
 662       if test "$compiler_c_o" = yes; then
 663         command="$command -o $obj"
 664         output_obj="$obj"
 665       fi
 666
 667       # Suppress compiler output if we already did a PIC compilation.
 668       command="$command$suppress_output"
 669       $run $rm "$output_obj"
 670       $show "$command"
 671       if $run eval "$command"; then :
 672       else
 673         $run $rm $removelist
 674         exit 1
 675       fi
 676
 677       if test "$need_locks" = warn &&
 678          test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
 679         echo "\
 680 *** ERROR, $lockfile contains:
 681 `cat $lockfile 2>/dev/null`
 682
 683 but it should contain:
 684 $srcfile
 685
 686 This indicates that another process is trying to use the same
 687 temporary object file, and libtool could not work around it because
 688 your compiler does not support \`-c' and \`-o' together.  If you
 689 repeat this compilation, it may succeed, by chance, but you had better
 690 avoid parallel builds (make -j) in this platform, or get a better
 691 compiler."
 692
 693         $run $rm $removelist
 694         exit 1
 695       fi
 696
 697       # Just move the object if needed
 698       if test x"$output_obj" != x"$obj"; then
 699         $show "$mv $output_obj $obj"
 700         if $run $mv $output_obj $obj; then :
 701         else
 702           error=$?
 703           $run $rm $removelist
 704           exit $error
 705         fi
 706       fi
 707
 708       # Create an invalid libtool object if no PIC, so that we do not
 709       # accidentally link it into a program.
 710       if test "$build_libtool_libs" != yes; then
 711         $show "echo timestamp > $libobj"
 712         $run eval "echo timestamp > \$libobj" || exit $?
 713       else
 714         # Move the .lo from within objdir
 715         $show "$mv $libobj $lo_libobj"
 716         if $run $mv $libobj $lo_libobj; then :
 717         else
 718           error=$?
 719           $run $rm $removelist
 720           exit $error
 721         fi
 722       fi
 723     fi
 724
 725     # Unlock the critical section if it was locked
 726     if test "$need_locks" != no; then
 727       $run $rm "$lockfile"
 728     fi
 729
 730     exit 0
 731     ;;
 732
 733   # libtool link mode
 734   link | relink)
 735     modename="$modename: link"
 736     case $host in
 737     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
 738       # It is impossible to link a dll without this setting, and
 739       # we shouldn't force the makefile maintainer to figure out
 740       # which system we are compiling for in order to pass an extra
 741       # flag for every libtool invokation.
 742       # allow_undefined=no
 743
 744       # FIXME: Unfortunately, there are problems with the above when trying
 745       # to make a dll which has undefined symbols, in which case not
 746       # even a static library is built.  For now, we need to specify
 747       # -no-undefined on the libtool link line when we can be certain
 748       # that all symbols are satisfied, otherwise we get a static library.
 749       allow_undefined=yes
 750       ;;
 751     *)
 752       allow_undefined=yes
 753       ;;
 754     esac
 755     libtool_args="$nonopt"
 756     compile_command="$nonopt"
 757     finalize_command="$nonopt"
 758
 759     compile_rpath=
 760     finalize_rpath=
 761     compile_shlibpath=
 762     finalize_shlibpath=
 763     convenience=
 764     old_convenience=
 765     deplibs=
 766     old_deplibs=
 767     compiler_flags=
 768     linker_flags=
 769     dllsearchpath=
 770     lib_search_path=`pwd`
 771     inst_prefix_dir=
 772
 773     avoid_version=no
 774     dlfiles=
 775     dlprefiles=
 776     dlself=no
 777     export_dynamic=no
 778     export_symbols=
 779     export_symbols_regex=
 780     generated=
 781     libobjs=
 782     ltlibs=
 783     module=no
 784     no_install=no
 785     objs=
 786     prefer_static_libs=no
 787     preload=no
 788     prev=
 789     prevarg=
 790     release=
 791     rpath=
 792     xrpath=
 793     perm_rpath=
 794     temp_rpath=
 795     thread_safe=no
 796     vinfo=
 797
 798     # We need to know -static, to get the right output filenames.
 799     for arg
 800     do
 801       case $arg in
 802       -all-static | -static)
 803         if test "X$arg" = "X-all-static"; then
 804           if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
 805             $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
 806           fi
 807           if test -n "$link_static_flag"; then
 808             dlopen_self=$dlopen_self_static
 809           fi
 810         else
 811           if test -z "$pic_flag" && test -n "$link_static_flag"; then
 812             dlopen_self=$dlopen_self_static
 813           fi
 814         fi
 815         build_libtool_libs=no
 816         build_old_libs=yes
 817         prefer_static_libs=yes
 818         break
 819         ;;
 820       esac
 821     done
 822
 823     # See if our shared archives depend on static archives.
 824     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
 825
 826     # Go through the arguments, transforming them on the way.
 827     while test $# -gt 0; do
 828       arg="$1"
 829       shift
 830       case $arg in
 831       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 832         qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
 833         ;;
 834       *) qarg=$arg ;;
 835       esac
 836       libtool_args="$libtool_args $qarg"
 837
 838       # If the previous option needs an argument, assign it.
 839       if test -n "$prev"; then
 840         case $prev in
 841         output)
 842           compile_command="$compile_command @OUTPUT@"
 843           finalize_command="$finalize_command @OUTPUT@"
 844           ;;
 845         esac
 846
 847         case $prev in
 848         dlfiles|dlprefiles)
 849           if test "$preload" = no; then
 850             # Add the symbol object into the linking commands.
 851             compile_command="$compile_command @SYMFILE@"
 852             finalize_command="$finalize_command @SYMFILE@"
 853             preload=yes
 854           fi
 855           case $arg in
 856           *.la | *.lo) ;;  # We handle these cases below.
 857           force)
 858             if test "$dlself" = no; then
 859               dlself=needless
 860               export_dynamic=yes
 861             fi
 862             prev=
 863             continue
 864             ;;
 865           self)
 866             if test "$prev" = dlprefiles; then
 867               dlself=yes
 868             elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
 869               dlself=yes
 870             else
 871               dlself=needless
 872               export_dynamic=yes
 873             fi
 874             prev=
 875             continue
 876             ;;
 877           *)
 878             if test "$prev" = dlfiles; then
 879               dlfiles="$dlfiles $arg"
 880             else
 881               dlprefiles="$dlprefiles $arg"
 882             fi
 883             prev=
 884             continue
 885             ;;
 886           esac
 887           ;;
 888         expsyms)
 889           export_symbols="$arg"
 890           if test ! -f "$arg"; then
 891             $echo "$modename: symbol file \`$arg' does not exist"
 892             exit 1
 893           fi
 894           prev=
 895           continue
 896           ;;
 897         expsyms_regex)
 898           export_symbols_regex="$arg"
 899           prev=
 900           continue
 901           ;;
 902         inst_prefix)
 903           inst_prefix_dir="$arg"
 904           prev=
 905           continue
 906           ;;
 907         release)
 908           release="-$arg"
 909           prev=
 910           continue
 911           ;;
 912         rpath | xrpath)
 913           # We need an absolute path.
 914           case $arg in
 915           [\\/]* | [A-Za-z]:[\\/]*) ;;
 916           *)
 917             $echo "$modename: only absolute run-paths are allowed" 1>&2
 918             exit 1
 919             ;;
 920           esac
 921           if test "$prev" = rpath; then
 922             case "$rpath " in
 923             *" $arg "*) ;;
 924             *) rpath="$rpath $arg" ;;
 925             esac
 926           else
 927             case "$xrpath " in
 928             *" $arg "*) ;;
 929             *) xrpath="$xrpath $arg" ;;
 930             esac
 931           fi
 932           prev=
 933           continue
 934           ;;
 935         xcompiler)
 936           compiler_flags="$compiler_flags $qarg"
 937           prev=
 938           compile_command="$compile_command $qarg"
 939           finalize_command="$finalize_command $qarg"
 940           continue
 941           ;;
 942         xlinker)
 943           linker_flags="$linker_flags $qarg"
 944           compiler_flags="$compiler_flags $wl$qarg"
 945           prev=
 946           compile_command="$compile_command $wl$qarg"
 947           finalize_command="$finalize_command $wl$qarg"
 948           continue
 949           ;;
 950         *)
 951           eval "$prev=\"\$arg\""
 952           prev=
 953           continue
 954           ;;
 955         esac
 956       fi # test -n $prev
 957
 958       prevarg="$arg"
 959
 960       case $arg in
 961       -all-static)
 962         if test -n "$link_static_flag"; then
 963           compile_command="$compile_command $link_static_flag"
 964           finalize_command="$finalize_command $link_static_flag"
 965         fi
 966         continue
 967         ;;
 968
 969       -allow-undefined)
 970         # FIXME: remove this flag sometime in the future.
 971         $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
 972         continue
 973         ;;
 974
 975       -avoid-version)
 976         avoid_version=yes
 977         continue
 978         ;;
 979
 980       -dlopen)
 981         prev=dlfiles
 982         continue
 983         ;;
 984
 985       -dlpreopen)
 986         prev=dlprefiles
 987         continue
 988         ;;
 989
 990       -export-dynamic)
 991         export_dynamic=yes
 992         continue
 993         ;;
 994
 995       -export-symbols | -export-symbols-regex)
 996         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
 997           $echo "$modename: more than one -exported-symbols argument is not allowed"
 998           exit 1
 999         fi
1000         if test "X$arg" = "X-export-symbols"; then
1001           prev=expsyms
1002         else
1003           prev=expsyms_regex
1004         fi
1005         continue
1006         ;;
1007
1008       -inst-prefix-dir)
1009        prev=inst_prefix
1010        continue
1011        ;;
1012
1013       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1014       # so, if we see these flags be careful not to treat them like -L
1015       -L[A-Z][A-Z]*:*)
1016         case $with_gcc/$host in
1017         no/*-*-irix* | no/*-*-nonstopux*)
1018           compile_command="$compile_command $arg"
1019           finalize_command="$finalize_command $arg"
1020           ;;
1021         esac
1022         continue
1023         ;;
1024
1025       -L*)
1026         dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1027         # We need an absolute path.
1028         case $dir in
1029         [\\/]* | [A-Za-z]:[\\/]*) ;;
1030         *)
1031           absdir=`cd "$dir" && pwd`
1032           if test -z "$absdir"; then
1033             $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1034             exit 1
1035           fi
1036           dir="$absdir"
1037           ;;
1038         esac
1039         case "$deplibs " in
1040         *" -L$dir "*) ;;
1041         *)
1042           deplibs="$deplibs -L$dir"
1043           lib_search_path="$lib_search_path $dir"
1044           ;;
1045         esac
1046         case $host in
1047         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1048           case :$dllsearchpath: in
1049           *":$dir:"*) ;;
1050           *) dllsearchpath="$dllsearchpath:$dir";;
1051           esac
1052           ;;
1053         esac
1054         continue
1055         ;;
1056
1057       -l*)
1058         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1059           case $host in
1060           *-*-cygwin* | *-*-pw32* | *-*-beos*)
1061             # These systems don't actually have a C or math library (as such)
1062             continue
1063             ;;
1064           *-*-mingw* | *-*-os2*)
1065             # These systems don't actually have a C library (as such)
1066             test "X$arg" = "X-lc" && continue
1067             ;;
1068           *-*-openbsd* | *-*-freebsd*)
1069             # Do not include libc due to us having libc/libc_r.
1070             test "X$arg" = "X-lc" && continue
1071             ;;
1072           esac
1073          elif test "X$arg" = "X-lc_r"; then
1074           case $host in
1075          *-*-openbsd* | *-*-freebsd*)
1076             # Do not include libc_r directly, use -pthread flag.
1077             continue
1078             ;;
1079           esac
1080         fi
1081         deplibs="$deplibs $arg"
1082         continue
1083         ;;
1084
1085       -module)
1086         module=yes
1087         continue
1088         ;;
1089
1090       -no-fast-install)
1091         fast_install=no
1092         continue
1093         ;;
1094
1095       -no-install)
1096         case $host in
1097         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1098           # The PATH hackery in wrapper scripts is required on Windows
1099           # in order for the loader to find any dlls it needs.
1100           $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1101           $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1102           fast_install=no
1103           ;;
1104         *) no_install=yes ;;
1105         esac
1106         continue
1107         ;;
1108
1109       -no-undefined)
1110         allow_undefined=no
1111         continue
1112         ;;
1113
1114       -o) prev=output ;;
1115
1116       -release)
1117         prev=release
1118         continue
1119         ;;
1120
1121       -rpath)
1122         prev=rpath
1123         continue
1124         ;;
1125
1126       -R)
1127         prev=xrpath
1128         continue
1129         ;;
1130
1131       -R*)
1132         dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1133         # We need an absolute path.
1134         case $dir in
1135         [\\/]* | [A-Za-z]:[\\/]*) ;;
1136         *)
1137           $echo "$modename: only absolute run-paths are allowed" 1>&2
1138           exit 1
1139           ;;
1140         esac
1141         case "$xrpath " in
1142         *" $dir "*) ;;
1143         *) xrpath="$xrpath $dir" ;;
1144         esac
1145         continue
1146         ;;
1147
1148       -static)
1149         # The effects of -static are defined in a previous loop.
1150         # We used to do the same as -all-static on platforms that
1151         # didn't have a PIC flag, but the assumption that the effects
1152         # would be equivalent was wrong.  It would break on at least
1153         # Digital Unix and AIX.
1154         continue
1155         ;;
1156
1157       -thread-safe)
1158         thread_safe=yes
1159         continue
1160         ;;
1161
1162       -version-info)
1163         prev=vinfo
1164         continue
1165         ;;
1166
1167       -Wc,*)
1168         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1169         arg=
1170         save_ifs="$IFS"; IFS=','
1171         for flag in $args; do
1172           IFS="$save_ifs"
1173           case $flag in
1174             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1175             flag="\"$flag\""
1176             ;;
1177           esac
1178           arg="$arg $wl$flag"
1179           compiler_flags="$compiler_flags $flag"
1180         done
1181         IFS="$save_ifs"
1182         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1183         ;;
1184
1185       -Wl,*)
1186         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1187         arg=
1188         save_ifs="$IFS"; IFS=','
1189         for flag in $args; do
1190           IFS="$save_ifs"
1191           case $flag in
1192             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1193             flag="\"$flag\""
1194             ;;
1195           esac
1196           arg="$arg $wl$flag"
1197           compiler_flags="$compiler_flags $wl$flag"
1198           linker_flags="$linker_flags $flag"
1199         done
1200         IFS="$save_ifs"
1201         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1202         ;;
1203
1204       -Xcompiler)
1205         prev=xcompiler
1206         continue
1207         ;;
1208
1209       -Xlinker)
1210         prev=xlinker
1211         continue
1212         ;;
1213
1214       # Some other compiler flag.
1215       -* | +*)
1216         # Unknown arguments in both finalize_command and compile_command need
1217         # to be aesthetically quoted because they are evaled later.
1218         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1219         case $arg in
1220         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1221           arg="\"$arg\""
1222           ;;
1223         esac
1224         ;;
1225
1226       *.lo | *.$objext)
1227         # A library or standard object.
1228         if test "$prev" = dlfiles; then
1229           # This file was specified with -dlopen.
1230           if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1231             dlfiles="$dlfiles $arg"
1232             prev=
1233             continue
1234           else
1235             # If libtool objects are unsupported, then we need to preload.
1236             prev=dlprefiles
1237           fi
1238         fi
1239
1240         if test "$prev" = dlprefiles; then
1241           # Preload the old-style object.
1242           dlprefiles="$dlprefiles "`$echo "X$arg" | $Xsed -e "$lo2o"`
1243           prev=
1244         else
1245           case $arg in
1246           *.lo) libobjs="$libobjs $arg" ;;
1247           *) objs="$objs $arg" ;;
1248           esac
1249         fi
1250         ;;
1251
1252       *.$libext)
1253         # An archive.
1254         deplibs="$deplibs $arg"
1255         old_deplibs="$old_deplibs $arg"
1256         continue
1257         ;;
1258
1259       *.la)
1260         # A libtool-controlled library.
1261
1262         if test "$prev" = dlfiles; then
1263           # This library was specified with -dlopen.
1264           dlfiles="$dlfiles $arg"
1265           prev=
1266         elif test "$prev" = dlprefiles; then
1267           # The library was specified with -dlpreopen.
1268           dlprefiles="$dlprefiles $arg"
1269           prev=
1270         else
1271           deplibs="$deplibs $arg"
1272         fi
1273         continue
1274         ;;
1275
1276       # Some other compiler argument.
1277       *)
1278         # Unknown arguments in both finalize_command and compile_command need
1279         # to be aesthetically quoted because they are evaled later.
1280         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1281         case $arg in
1282         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1283           arg="\"$arg\""
1284           ;;
1285         esac
1286         ;;
1287       esac # arg
1288
1289       # Now actually substitute the argument into the commands.
1290       if test -n "$arg"; then
1291         compile_command="$compile_command $arg"
1292         finalize_command="$finalize_command $arg"
1293       fi
1294     done # argument parsing loop
1295
1296     if test -n "$prev"; then
1297       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1298       $echo "$help" 1>&2
1299       exit 1
1300     fi
1301
1302     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1303       eval arg=\"$export_dynamic_flag_spec\"
1304       compile_command="$compile_command $arg"
1305       finalize_command="$finalize_command $arg"
1306     fi
1307
1308     # calculate the name of the file, without its directory
1309     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1310     libobjs_save="$libobjs"
1311
1312     if test -n "$shlibpath_var"; then
1313       # get the directories listed in $shlibpath_var
1314       eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
1315     else
1316       shlib_search_path=
1317     fi
1318     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1319     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1320
1321     output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1322     if test "X$output_objdir" = "X$output"; then
1323       output_objdir="$objdir"
1324     else
1325       output_objdir="$output_objdir/$objdir"
1326     fi
1327     # Create the object directory.
1328     if test ! -d $output_objdir; then
1329       $show "$mkdir $output_objdir"
1330       $run $mkdir $output_objdir
1331       status=$?
1332       if test $status -ne 0 && test ! -d $output_objdir; then
1333         exit $status
1334       fi
1335     fi
1336
1337     # Determine the type of output
1338     case $output in
1339     "")
1340       $echo "$modename: you must specify an output file" 1>&2
1341       $echo "$help" 1>&2
1342       exit 1
1343       ;;
1344     *.$libext) linkmode=oldlib ;;
1345     *.lo | *.$objext) linkmode=obj ;;
1346     *.la) linkmode=lib ;;
1347     *) linkmode=prog ;; # Anything else should be a program.
1348     esac
1349
1350     specialdeplibs=
1351     libs=
1352     # Find all interdependent deplibs by searching for libraries
1353     # that are linked more than once (e.g. -la -lb -la)
1354     for deplib in $deplibs; do
1355       if test "X$duplicate_deps" = "Xyes" ; then
1356         case "$libs " in
1357         *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1358         esac
1359       fi
1360       libs="$libs $deplib"
1361     done
1362     deplibs=
1363     newdependency_libs=
1364     newlib_search_path=
1365     need_relink=no # whether we're linking any uninstalled libtool libraries
1366     notinst_deplibs= # not-installed libtool libraries
1367     notinst_path= # paths that contain not-installed libtool libraries
1368     case $linkmode in
1369     lib)
1370         passes="conv link"
1371         for file in $dlfiles $dlprefiles; do
1372           case $file in
1373           *.la) ;;
1374           *)
1375             $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1376             exit 1
1377             ;;
1378           esac
1379         done
1380         ;;
1381     prog)
1382         compile_deplibs=
1383         finalize_deplibs=
1384         alldeplibs=no
1385         newdlfiles=
1386         newdlprefiles=
1387         passes="conv scan dlopen dlpreopen link"
1388         ;;
1389     *)  passes="conv"
1390         ;;
1391     esac
1392     for pass in $passes; do
1393       if test $linkmode = prog; then
1394         # Determine which files to process
1395         case $pass in
1396         dlopen)
1397           libs="$dlfiles"
1398           save_deplibs="$deplibs" # Collect dlpreopened libraries
1399           deplibs=
1400           ;;
1401         dlpreopen) libs="$dlprefiles" ;;
1402         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
1403         esac
1404       fi
1405       for deplib in $libs; do
1406         lib=
1407         found=no
1408         case $deplib in
1409         -l*)
1410           if test $linkmode = oldlib && test $linkmode = obj; then
1411             $echo "$modename: warning: \`-l' is ignored for archives/objects: $deplib" 1>&2
1412             continue
1413           fi
1414           if test $pass = conv; then
1415             deplibs="$deplib $deplibs"
1416             continue
1417           fi
1418           name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
1419           for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
1420             # Search the libtool library
1421             lib="$searchdir/lib${name}.la"
1422             if test -f "$lib"; then
1423               found=yes
1424               break
1425             fi
1426           done
1427           if test "$found" != yes; then
1428             # deplib doesn't seem to be a libtool library
1429             if test "$linkmode,$pass" = "prog,link"; then
1430               compile_deplibs="$deplib $compile_deplibs"
1431               finalize_deplibs="$deplib $finalize_deplibs"
1432             else
1433               deplibs="$deplib $deplibs"
1434               test $linkmode = lib && newdependency_libs="$deplib $newdependency_libs"
1435             fi
1436             continue
1437           fi
1438           ;; # -l
1439         -L*)
1440           case $linkmode in
1441           lib)
1442             deplibs="$deplib $deplibs"
1443             test $pass = conv && continue
1444             newdependency_libs="$deplib $newdependency_libs"
1445             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1446             ;;
1447           prog)
1448             if test $pass = conv; then
1449               deplibs="$deplib $deplibs"
1450               continue
1451             fi
1452             if test $pass = scan; then
1453               deplibs="$deplib $deplibs"
1454               newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1455             else
1456               compile_deplibs="$deplib $compile_deplibs"
1457               finalize_deplibs="$deplib $finalize_deplibs"
1458             fi
1459             ;;
1460           *)
1461             $echo "$modename: warning: \`-L' is ignored for archives/objects: $deplib" 1>&2
1462             ;;
1463           esac # linkmode
1464           continue
1465           ;; # -L
1466         -R*)
1467           if test $pass = link; then
1468             dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
1469             # Make sure the xrpath contains only unique directories.
1470             case "$xrpath " in
1471             *" $dir "*) ;;
1472             *) xrpath="$xrpath $dir" ;;
1473             esac
1474           fi
1475           deplibs="$deplib $deplibs"
1476           continue
1477           ;;
1478         *.la) lib="$deplib" ;;
1479         *.$libext)
1480           if test $pass = conv; then
1481             deplibs="$deplib $deplibs"
1482             continue
1483           fi
1484           case $linkmode in
1485           lib)
1486             if test "$deplibs_check_method" != pass_all; then
1487               echo
1488               echo "*** Warning: Trying to link with static lib archive $deplib."
1489               echo "*** I have the capability to make that library automatically link in when"
1490               echo "*** you link to this library.  But I can only do this if you have a"
1491               echo "*** shared version of the library, which you do not appear to have"
1492               echo "*** because the file extensions .$libext of this argument makes me believe"
1493               echo "*** that it is just a static archive that I should not used here."
1494             else
1495               echo
1496               echo "*** Warning: Linking the shared library $output against the"
1497               echo "*** static library $deplib is not portable!"
1498               deplibs="$deplib $deplibs"
1499             fi
1500             continue
1501             ;;
1502           prog)
1503             if test $pass != link; then
1504               deplibs="$deplib $deplibs"
1505             else
1506               compile_deplibs="$deplib $compile_deplibs"
1507               finalize_deplibs="$deplib $finalize_deplibs"
1508             fi
1509             continue
1510             ;;
1511           esac # linkmode
1512           ;; # *.$libext
1513         *.lo | *.$objext)
1514           if test $pass = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
1515             # If there is no dlopen support or we're linking statically,
1516             # we need to preload.
1517             newdlprefiles="$newdlprefiles $deplib"
1518             compile_deplibs="$deplib $compile_deplibs"
1519             finalize_deplibs="$deplib $finalize_deplibs"
1520           else
1521             newdlfiles="$newdlfiles $deplib"
1522           fi
1523           continue
1524           ;;
1525         %DEPLIBS%)
1526           alldeplibs=yes
1527           continue
1528           ;;
1529         esac # case $deplib
1530         if test $found = yes || test -f "$lib"; then :
1531         else
1532           $echo "$modename: cannot find the library \`$lib'" 1>&2
1533           exit 1
1534         fi
1535
1536         # Check to see that this really is a libtool archive.
1537         if (${SED} -e '2q' $lib | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
1538         else
1539           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
1540           exit 1
1541         fi
1542
1543         ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
1544         test "X$ladir" = "X$lib" && ladir="."
1545
1546         dlname=
1547         dlopen=
1548         dlpreopen=
1549         libdir=
1550         library_names=
1551         old_library=
1552         # If the library was installed with an old release of libtool,
1553         # it will not redefine variable installed.
1554         installed=yes
1555
1556         # Read the .la file
1557         case $lib in
1558         */* | *\\*) . $lib ;;
1559         *) . ./$lib ;;
1560         esac
1561
1562         if test "$linkmode,$pass" = "lib,link" ||
1563            test "$linkmode,$pass" = "prog,scan" ||
1564            { test $linkmode = oldlib && test $linkmode = obj; }; then
1565            # Add dl[pre]opened files of deplib
1566           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
1567           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
1568         fi
1569
1570         if test $pass = conv; then
1571           # Only check for convenience libraries
1572           deplibs="$lib $deplibs"
1573           if test -z "$libdir"; then
1574             if test -z "$old_library"; then
1575               $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
1576               exit 1
1577             fi
1578             # It is a libtool convenience library, so add in its objects.
1579             convenience="$convenience $ladir/$objdir/$old_library"
1580             old_convenience="$old_convenience $ladir/$objdir/$old_library"
1581             tmp_libs=
1582             for deplib in $dependency_libs; do
1583               deplibs="$deplib $deplibs"
1584               if test "X$duplicate_deps" = "Xyes" ; then
1585                 case "$tmp_libs " in
1586                 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1587                 esac
1588               fi
1589               tmp_libs="$tmp_libs $deplib"
1590             done
1591           elif test $linkmode != prog && test $linkmode != lib; then
1592             $echo "$modename: \`$lib' is not a convenience library" 1>&2
1593             exit 1
1594           fi
1595           continue
1596         fi # $pass = conv
1597
1598         # Get the name of the library we link against.
1599         linklib=
1600         for l in $old_library $library_names; do
1601           linklib="$l"
1602         done
1603         if test -z "$linklib"; then
1604           $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
1605           exit 1
1606         fi
1607
1608         # This library was specified with -dlopen.
1609         if test $pass = dlopen; then
1610           if test -z "$libdir"; then
1611             $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
1612             exit 1
1613           fi
1614           if test -z "$dlname" || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
1615             # If there is no dlname, no dlopen support or we're linking
1616             # statically, we need to preload.
1617             dlprefiles="$dlprefiles $lib"
1618           else
1619             newdlfiles="$newdlfiles $lib"
1620           fi
1621           continue
1622         fi # $pass = dlopen
1623
1624         # We need an absolute path.
1625         case $ladir in
1626         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
1627         *)
1628           abs_ladir=`cd "$ladir" && pwd`
1629           if test -z "$abs_ladir"; then
1630             $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
1631             $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
1632             abs_ladir="$ladir"
1633           fi
1634           ;;
1635         esac
1636         laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
1637
1638         # Find the relevant object directory and library name.
1639         if test "X$installed" = Xyes; then
1640           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
1641             $echo "$modename: warning: library \`$lib' was moved." 1>&2
1642             dir="$ladir"
1643             absdir="$abs_ladir"
1644             libdir="$abs_ladir"
1645           else
1646             dir="$libdir"
1647             absdir="$libdir"
1648           fi
1649         else
1650           dir="$ladir/$objdir"
1651           absdir="$abs_ladir/$objdir"
1652           # Remove this search path later
1653           notinst_path="$notinst_path $abs_ladir"
1654         fi # $installed = yes
1655         name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
1656
1657         # This library was specified with -dlpreopen.
1658         if test $pass = dlpreopen; then
1659           if test -z "$libdir"; then
1660             $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
1661             exit 1
1662           fi
1663           # Prefer using a static library (so that no silly _DYNAMIC symbols
1664           # are required to link).
1665           if test -n "$old_library"; then
1666             newdlprefiles="$newdlprefiles $dir/$old_library"
1667           # Otherwise, use the dlname, so that lt_dlopen finds it.
1668           elif test -n "$dlname"; then
1669             newdlprefiles="$newdlprefiles $dir/$dlname"
1670           else
1671             newdlprefiles="$newdlprefiles $dir/$linklib"
1672           fi
1673         fi # $pass = dlpreopen
1674
1675         if test -z "$libdir"; then
1676           # Link the convenience library
1677           if test $linkmode = lib; then
1678             deplibs="$dir/$old_library $deplibs"
1679           elif test "$linkmode,$pass" = "prog,link"; then
1680             compile_deplibs="$dir/$old_library $compile_deplibs"
1681             finalize_deplibs="$dir/$old_library $finalize_deplibs"
1682           else
1683             deplibs="$lib $deplibs"
1684           fi
1685           continue
1686         fi
1687
1688         if test $linkmode = prog && test $pass != link; then
1689           newlib_search_path="$newlib_search_path $ladir"
1690           deplibs="$lib $deplibs"
1691
1692           linkalldeplibs=no
1693           if test "$link_all_deplibs" != no || test -z "$library_names" ||
1694              test "$build_libtool_libs" = no; then
1695             linkalldeplibs=yes
1696           fi
1697
1698           tmp_libs=
1699           for deplib in $dependency_libs; do
1700             case $deplib in
1701             -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
1702             esac
1703             # Need to link against all dependency_libs?
1704             if test $linkalldeplibs = yes; then
1705               deplibs="$deplib $deplibs"
1706             else
1707               # Need to hardcode shared library paths
1708               # or/and link against static libraries
1709               newdependency_libs="$deplib $newdependency_libs"
1710             fi
1711             if test "X$duplicate_deps" = "Xyes" ; then
1712               case "$tmp_libs " in
1713               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1714               esac
1715             fi
1716             tmp_libs="$tmp_libs $deplib"
1717           done # for deplib
1718           continue
1719         fi # $linkmode = prog...
1720
1721         link_static=no # Whether the deplib will be linked statically
1722         if test -n "$library_names" &&
1723            { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
1724           # Link against this shared library
1725
1726           if test "$linkmode,$pass" = "prog,link" ||
1727            { test $linkmode = lib && test $hardcode_into_libs = yes; }; then
1728             # Hardcode the library path.
1729             # Skip directories that are in the system default run-time
1730             # search path.
1731             case " $sys_lib_dlsearch_path " in
1732             *" $absdir "*) ;;
1733             *)
1734               case "$compile_rpath " in
1735               *" $absdir "*) ;;
1736               *) compile_rpath="$compile_rpath $absdir"
1737               esac
1738               ;;
1739             esac
1740             case " $sys_lib_dlsearch_path " in
1741             *" $libdir "*) ;;
1742             *)
1743               case "$finalize_rpath " in
1744               *" $libdir "*) ;;
1745               *) finalize_rpath="$finalize_rpath $libdir"
1746               esac
1747               ;;
1748             esac
1749             if test $linkmode = prog; then
1750               # We need to hardcode the library path
1751               if test -n "$shlibpath_var"; then
1752                 # Make sure the rpath contains only unique directories.
1753                 case "$temp_rpath " in
1754                 *" $dir "*) ;;
1755                 *" $absdir "*) ;;
1756                 *) temp_rpath="$temp_rpath $dir" ;;
1757                 esac
1758               fi
1759             fi
1760           fi # $linkmode,$pass = prog,link...
1761
1762           if test "$alldeplibs" = yes &&
1763              { test "$deplibs_check_method" = pass_all ||
1764                { test "$build_libtool_libs" = yes &&
1765                  test -n "$library_names"; }; }; then
1766             # We only need to search for static libraries
1767             continue
1768           fi
1769
1770           if test "$installed" = no; then
1771             notinst_deplibs="$notinst_deplibs $lib"
1772             need_relink=yes
1773           fi
1774
1775           if test -n "$old_archive_from_expsyms_cmds"; then
1776             # figure out the soname
1777             set dummy $library_names
1778             realname="$2"
1779             shift; shift
1780             libname=`eval \\$echo \"$libname_spec\"`
1781             # use dlname if we got it. it's perfectly good, no?
1782             if test -n "$dlname"; then
1783               soname="$dlname"
1784             elif test -n "$soname_spec"; then
1785               # bleh windows
1786               case $host in
1787               *cygwin*)
1788                 major=`expr $current - $age`
1789                 versuffix="-$major"
1790                 ;;
1791               esac
1792               eval soname=\"$soname_spec\"
1793             else
1794               soname="$realname"
1795             fi
1796
1797             # Make a new name for the extract_expsyms_cmds to use
1798             soroot="$soname"
1799             soname=`echo $soroot | ${SED} -e 's/^.*\///'`
1800             newlib="libimp-`echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
1801
1802             # If the library has no export list, then create one now
1803             if test -f "$output_objdir/$soname-def"; then :
1804             else
1805               $show "extracting exported symbol list from \`$soname'"
1806               save_ifs="$IFS"; IFS='~'
1807               eval cmds=\"$extract_expsyms_cmds\"
1808               for cmd in $cmds; do
1809                 IFS="$save_ifs"
1810                 $show "$cmd"
1811                 $run eval "$cmd" || exit $?
1812               done
1813               IFS="$save_ifs"
1814             fi
1815
1816             # Create $newlib
1817             if test -f "$output_objdir/$newlib"; then :; else
1818               $show "generating import library for \`$soname'"
1819               save_ifs="$IFS"; IFS='~'
1820               eval cmds=\"$old_archive_from_expsyms_cmds\"
1821               for cmd in $cmds; do
1822                 IFS="$save_ifs"
1823                 $show "$cmd"
1824                 $run eval "$cmd" || exit $?
1825               done
1826               IFS="$save_ifs"
1827             fi
1828             # make sure the library variables are pointing to the new library
1829             dir=$output_objdir
1830             linklib=$newlib
1831           fi # test -n $old_archive_from_expsyms_cmds
1832
1833           if test $linkmode = prog || test "$mode" != relink; then
1834             add_shlibpath=
1835             add_dir=
1836             add=
1837             lib_linked=yes
1838             case $hardcode_action in
1839             immediate | unsupported)
1840               if test "$hardcode_direct" = no; then
1841                 add="$dir/$linklib"
1842               elif test "$hardcode_minus_L" = no; then
1843                 case $host in
1844                 *-*-sunos*) add_shlibpath="$dir" ;;
1845                 esac
1846                 add_dir="-L$dir"
1847                 add="-l$name"
1848               elif test "$hardcode_shlibpath_var" = no; then
1849                 add_shlibpath="$dir"
1850                 add="-l$name"
1851               else
1852                 lib_linked=no
1853               fi
1854               ;;
1855             relink)
1856               if test "$hardcode_direct" = yes; then
1857                 add="$dir/$linklib"
1858               elif test "$hardcode_minus_L" = yes; then
1859                 add_dir="-L$dir"
1860                 # Try looking first in the location we're being installed to.
1861                 if test -n "$inst_prefix_dir"; then
1862                   case "$libdir" in
1863                   [\/]*)
1864                     add_dir="-L$inst_prefix_dir$libdir $add_dir"
1865                     ;;
1866                   esac
1867                 fi
1868                 add="-l$name"
1869               elif test "$hardcode_shlibpath_var" = yes; then
1870                 add_shlibpath="$dir"
1871                 add="-l$name"
1872               else
1873                 lib_linked=no
1874               fi
1875               ;;
1876             *) lib_linked=no ;;
1877             esac
1878
1879             if test "$lib_linked" != yes; then
1880               $echo "$modename: configuration error: unsupported hardcode properties"
1881               exit 1
1882             fi
1883
1884             if test -n "$add_shlibpath"; then
1885               case :$compile_shlibpath: in
1886               *":$add_shlibpath:"*) ;;
1887               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
1888               esac
1889             fi
1890             if test $linkmode = prog; then
1891               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
1892               test -n "$add" && compile_deplibs="$add $compile_deplibs"
1893             else
1894               test -n "$add_dir" && deplibs="$add_dir $deplibs"
1895               test -n "$add" && deplibs="$add $deplibs"
1896               if test "$hardcode_direct" != yes && \
1897                  test "$hardcode_minus_L" != yes && \
1898                  test "$hardcode_shlibpath_var" = yes; then
1899                 case :$finalize_shlibpath: in
1900                 *":$libdir:"*) ;;
1901                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
1902                 esac
1903               fi
1904             fi
1905           fi
1906
1907           if test $linkmode = prog || test "$mode" = relink; then
1908             add_shlibpath=
1909             add_dir=
1910             add=
1911             # Finalize command for both is simple: just hardcode it.
1912             if test "$hardcode_direct" = yes; then
1913               add="$libdir/$linklib"
1914             elif test "$hardcode_minus_L" = yes; then
1915               add_dir="-L$libdir"
1916               add="-l$name"
1917             elif test "$hardcode_shlibpath_var" = yes; then
1918               case :$finalize_shlibpath: in
1919               *":$libdir:"*) ;;
1920               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
1921               esac
1922               add="-l$name"
1923             else
1924               # We cannot seem to hardcode it, guess we'll fake it.
1925               add_dir="-L$libdir"
1926               # Try looking first in the location we're being installed to.
1927               if test -n "$inst_prefix_dir"; then
1928                 case "$libdir" in
1929                 [\/]*)
1930                   add_dir="-L$inst_prefix_dir$libdir $add_dir"
1931                   ;;
1932                 esac
1933               fi
1934               add="-l$name"
1935             fi
1936
1937             if test $linkmode = prog; then
1938               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
1939               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
1940             else
1941               test -n "$add_dir" && deplibs="$add_dir $deplibs"
1942               test -n "$add" && deplibs="$add $deplibs"
1943             fi
1944           fi
1945         elif test $linkmode = prog; then
1946           if test "$alldeplibs" = yes &&
1947              { test "$deplibs_check_method" = pass_all ||
1948                { test "$build_libtool_libs" = yes &&
1949                  test -n "$library_names"; }; }; then
1950             # We only need to search for static libraries
1951             continue
1952           fi
1953
1954           # Try to link the static library
1955           # Here we assume that one of hardcode_direct or hardcode_minus_L
1956           # is not unsupported.  This is valid on all known static and
1957           # shared platforms.
1958           if test "$hardcode_direct" != unsupported; then
1959             test -n "$old_library" && linklib="$old_library"
1960             compile_deplibs="$dir/$linklib $compile_deplibs"
1961             finalize_deplibs="$dir/$linklib $finalize_deplibs"
1962           else
1963             compile_deplibs="-l$name -L$dir $compile_deplibs"
1964             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
1965           fi
1966         elif test "$build_libtool_libs" = yes; then
1967           # Not a shared library
1968           if test "$deplibs_check_method" != pass_all; then
1969             # We're trying link a shared library against a static one
1970             # but the system doesn't support it.
1971
1972             # Just print a warning and add the library to dependency_libs so
1973             # that the program can be linked against the static library.
1974             echo
1975             echo "*** Warning: This system can not link to static lib archive $lib."
1976             echo "*** I have the capability to make that library automatically link in when"
1977             echo "*** you link to this library.  But I can only do this if you have a"
1978             echo "*** shared version of the library, which you do not appear to have."
1979             if test "$module" = yes; then
1980               echo "*** But as you try to build a module library, libtool will still create "
1981               echo "*** a static module, that should work as long as the dlopening application"
1982               echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
1983               if test -z "$global_symbol_pipe"; then
1984                 echo
1985                 echo "*** However, this would only work if libtool was able to extract symbol"
1986                 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
1987                 echo "*** not find such a program.  So, this module is probably useless."
1988                 echo "*** \`nm' from GNU binutils and a full rebuild may help."
1989               fi
1990               if test "$build_old_libs" = no; then
1991                 build_libtool_libs=module
1992                 build_old_libs=yes
1993               else
1994                 build_libtool_libs=no
1995               fi
1996             fi
1997           else
1998             convenience="$convenience $dir/$old_library"
1999             old_convenience="$old_convenience $dir/$old_library"
2000             deplibs="$dir/$old_library $deplibs"
2001             link_static=yes
2002           fi
2003         fi # link shared/static library?
2004
2005         if test $linkmode = lib; then
2006           if test -n "$dependency_libs" &&
2007              { test $hardcode_into_libs != yes || test $build_old_libs = yes ||
2008                test $link_static = yes; }; then
2009             # Extract -R from dependency_libs
2010             temp_deplibs=
2011             for libdir in $dependency_libs; do
2012               case $libdir in
2013               -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2014                    case " $xrpath " in
2015                    *" $temp_xrpath "*) ;;
2016                    *) xrpath="$xrpath $temp_xrpath";;
2017                    esac;;
2018               *) temp_deplibs="$temp_deplibs $libdir";;
2019               esac
2020             done
2021             dependency_libs="$temp_deplibs"
2022           fi
2023
2024           newlib_search_path="$newlib_search_path $absdir"
2025           # Link against this library
2026           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2027           # ... and its dependency_libs
2028           tmp_libs=
2029           for deplib in $dependency_libs; do
2030             newdependency_libs="$deplib $newdependency_libs"
2031             if test "X$duplicate_deps" = "Xyes" ; then
2032               case "$tmp_libs " in
2033               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2034               esac
2035             fi
2036             tmp_libs="$tmp_libs $deplib"
2037           done
2038
2039           if test $link_all_deplibs != no; then
2040             # Add the search paths of all dependency libraries
2041             for deplib in $dependency_libs; do
2042               case $deplib in
2043               -L*) path="$deplib" ;;
2044               *.la)
2045                 dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2046                 test "X$dir" = "X$deplib" && dir="."
2047                 # We need an absolute path.
2048                 case $dir in
2049                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2050                 *)
2051                   absdir=`cd "$dir" && pwd`
2052                   if test -z "$absdir"; then
2053                     $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2054                     absdir="$dir"
2055                   fi
2056                   ;;
2057                 esac
2058                 if grep "^installed=no" $deplib > /dev/null; then
2059                   path="-L$absdir/$objdir"
2060                 else
2061                   eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2062                   if test -z "$libdir"; then
2063                     $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2064                     exit 1
2065                   fi
2066                   if test "$absdir" != "$libdir"; then
2067                     $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2068                   fi
2069                   path="-L$absdir"
2070                 fi
2071                 ;;
2072               *) continue ;;
2073               esac
2074               case " $deplibs " in
2075               *" $path "*) ;;
2076               *) deplibs="$deplibs $path" ;;
2077               esac
2078             done
2079           fi # link_all_deplibs != no
2080         fi # linkmode = lib
2081       done # for deplib in $libs
2082       if test $pass = dlpreopen; then
2083         # Link the dlpreopened libraries before other libraries
2084         for deplib in $save_deplibs; do
2085           deplibs="$deplib $deplibs"
2086         done
2087       fi
2088       if test $pass != dlopen; then
2089         test $pass != scan && dependency_libs="$newdependency_libs"
2090         if test $pass != conv; then
2091           # Make sure lib_search_path contains only unique directories.
2092           lib_search_path=
2093           for dir in $newlib_search_path; do
2094             case "$lib_search_path " in
2095             *" $dir "*) ;;
2096             *) lib_search_path="$lib_search_path $dir" ;;
2097             esac
2098           done
2099           newlib_search_path=
2100         fi
2101
2102         if test "$linkmode,$pass" != "prog,link"; then
2103           vars="deplibs"
2104         else
2105           vars="compile_deplibs finalize_deplibs"
2106         fi
2107         for var in $vars dependency_libs; do
2108           # Add libraries to $var in reverse order
2109           eval tmp_libs=\"\$$var\"
2110           new_libs=
2111           for deplib in $tmp_libs; do
2112             case $deplib in
2113             -L*) new_libs="$deplib $new_libs" ;;
2114             *)
2115               case " $specialdeplibs " in
2116               *" $deplib "*) new_libs="$deplib $new_libs" ;;
2117               *)
2118                 case " $new_libs " in
2119                 *" $deplib "*) ;;
2120                 *) new_libs="$deplib $new_libs" ;;
2121                 esac
2122                 ;;
2123               esac
2124               ;;
2125             esac
2126           done
2127           tmp_libs=
2128           for deplib in $new_libs; do
2129             case $deplib in
2130             -L*)
2131               case " $tmp_libs " in
2132               *" $deplib "*) ;;
2133               *) tmp_libs="$tmp_libs $deplib" ;;
2134               esac
2135               ;;
2136             *) tmp_libs="$tmp_libs $deplib" ;;
2137             esac
2138           done
2139           eval $var=\"$tmp_libs\"
2140         done # for var
2141       fi
2142       if test "$pass" = "conv" &&
2143        { test "$linkmode" = "lib" || test "$linkmode" = "prog"; }; then
2144         libs="$deplibs" # reset libs
2145         deplibs=
2146       fi
2147     done # for pass
2148     if test $linkmode = prog; then
2149       dlfiles="$newdlfiles"
2150       dlprefiles="$newdlprefiles"
2151     fi
2152
2153     case $linkmode in
2154     oldlib)
2155       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2156         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
2157       fi
2158
2159       if test -n "$rpath"; then
2160         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2161       fi
2162
2163       if test -n "$xrpath"; then
2164         $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2165       fi
2166
2167       if test -n "$vinfo"; then
2168         $echo "$modename: warning: \`-version-info' is ignored for archives" 1>&2
2169       fi
2170
2171       if test -n "$release"; then
2172         $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2173       fi
2174
2175       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2176         $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2177       fi
2178
2179       # Now set the variables for building old libraries.
2180       build_libtool_libs=no
2181       oldlibs="$output"
2182       objs="$objs$old_deplibs"
2183       ;;
2184
2185     lib)
2186       # Make sure we only generate libraries of the form `libNAME.la'.
2187       case $outputname in
2188       lib*)
2189         name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2190         eval libname=\"$libname_spec\"
2191         ;;
2192       *)
2193         if test "$module" = no; then
2194           $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
2195           $echo "$help" 1>&2
2196           exit 1
2197         fi
2198         if test "$need_lib_prefix" != no; then
2199           # Add the "lib" prefix for modules if required
2200           name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2201           eval libname=\"$libname_spec\"
2202         else
2203           libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2204         fi
2205         ;;
2206       esac
2207
2208       if test -n "$objs"; then
2209         if test "$deplibs_check_method" != pass_all; then
2210           $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
2211           exit 1
2212         else
2213           echo
2214           echo "*** Warning: Linking the shared library $output against the non-libtool"
2215           echo "*** objects $objs is not portable!"
2216           libobjs="$libobjs $objs"
2217         fi
2218       fi
2219
2220       if test "$dlself" != no; then
2221         $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
2222       fi
2223
2224       set dummy $rpath
2225       if test $# -gt 2; then
2226         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
2227       fi
2228       install_libdir="$2"
2229
2230       oldlibs=
2231       if test -z "$rpath"; then
2232         if test "$build_libtool_libs" = yes; then
2233           # Building a libtool convenience library.
2234           libext=al
2235           oldlibs="$output_objdir/$libname.$libext $oldlibs"
2236           build_libtool_libs=convenience
2237           build_old_libs=yes
2238         fi
2239
2240         if test -n "$vinfo"; then
2241           $echo "$modename: warning: \`-version-info' is ignored for convenience libraries" 1>&2
2242         fi
2243
2244         if test -n "$release"; then
2245           $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
2246         fi
2247       else
2248
2249         # Parse the version information argument.
2250         save_ifs="$IFS"; IFS=':'
2251         set dummy $vinfo 0 0 0
2252         IFS="$save_ifs"
2253
2254         if test -n "$8"; then
2255           $echo "$modename: too many parameters to \`-version-info'" 1>&2
2256           $echo "$help" 1>&2
2257           exit 1
2258         fi
2259
2260         current="$2"
2261         revision="$3"
2262         age="$4"
2263
2264         # Check that each of the things are valid numbers.
2265         case $current in
2266         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2267         *)
2268           $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
2269           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2270           exit 1
2271           ;;
2272         esac
2273
2274         case $revision in
2275         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2276         *)
2277           $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
2278           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2279           exit 1
2280           ;;
2281         esac
2282
2283         case $age in
2284         0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2285         *)
2286           $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
2287           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2288           exit 1
2289           ;;
2290         esac
2291
2292         if test $age -gt $current; then
2293           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
2294           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2295           exit 1
2296         fi
2297
2298         # Calculate the version variables.
2299         major=
2300         versuffix=
2301         verstring=
2302         case $version_type in
2303         none) ;;
2304
2305         darwin)
2306           # Like Linux, but with the current version available in
2307           # verstring for coding it into the library header
2308           major=.`expr $current - $age`
2309           versuffix="$major.$age.$revision"
2310           # Darwin ld doesn't like 0 for these options...
2311           minor_current=`expr $current + 1`
2312           verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
2313           ;;
2314
2315         freebsd-aout)
2316           major=".$current"
2317           versuffix=".$current.$revision";
2318           ;;
2319
2320         freebsd-elf)
2321           major=".$current"
2322           versuffix=".$current";
2323           ;;
2324
2325         irix | nonstopux)
2326           major=`expr $current - $age + 1`
2327
2328           case $version_type in
2329             nonstopux) verstring_prefix=nonstopux ;;
2330             *)         verstring_prefix=sgi ;;
2331           esac
2332           verstring="$verstring_prefix$major.$revision"
2333
2334           # Add in all the interfaces that we are compatible with.
2335           loop=$revision
2336           while test $loop != 0; do
2337             iface=`expr $revision - $loop`
2338             loop=`expr $loop - 1`
2339             verstring="$verstring_prefix$major.$iface:$verstring"
2340           done
2341
2342           # Before this point, $major must not contain `.'.
2343           major=.$major
2344           versuffix="$major.$revision"
2345           ;;
2346
2347         linux)
2348           major=.`expr $current - $age`
2349           versuffix="$major.$age.$revision"
2350           ;;
2351
2352         osf)
2353           major=.`expr $current - $age`
2354           versuffix=".$current.$age.$revision"
2355           verstring="$current.$age.$revision"
2356
2357           # Add in all the interfaces that we are compatible with.
2358           loop=$age
2359           while test $loop != 0; do
2360             iface=`expr $current - $loop`
2361             loop=`expr $loop - 1`
2362             verstring="$verstring:${iface}.0"
2363           done
2364
2365           # Make executables depend on our current version.
2366           verstring="$verstring:${current}.0"
2367           ;;
2368
2369         sunos)
2370           major=".$current"
2371           versuffix=".$current.$revision"
2372           ;;
2373
2374         windows)
2375           # Use '-' rather than '.', since we only want one
2376           # extension on DOS 8.3 filesystems.
2377           major=`expr $current - $age`
2378           versuffix="-$major"
2379           ;;
2380
2381         *)
2382           $echo "$modename: unknown library version type \`$version_type'" 1>&2
2383           echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
2384           exit 1
2385           ;;
2386         esac
2387
2388         # Clear the version info if we defaulted, and they specified a release.
2389         if test -z "$vinfo" && test -n "$release"; then
2390           major=
2391           verstring="0.0"
2392           case $version_type in
2393           darwin)
2394             # we can't check for "0.0" in archive_cmds due to quoting
2395             # problems, so we reset it completely
2396             verstring=""
2397             ;;
2398           *)
2399             verstring="0.0"
2400             ;;
2401           esac
2402           if test "$need_version" = no; then
2403             versuffix=
2404           else
2405             versuffix=".0.0"
2406           fi
2407         fi
2408
2409         # Remove version info from name if versioning should be avoided
2410         if test "$avoid_version" = yes && test "$need_version" = no; then
2411           major=
2412           versuffix=
2413           verstring=""
2414         fi
2415
2416         # Check to see if the archive will have undefined symbols.
2417         if test "$allow_undefined" = yes; then
2418           if test "$allow_undefined_flag" = unsupported; then
2419             $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
2420             build_libtool_libs=no
2421             build_old_libs=yes
2422           fi
2423         else
2424           # Don't allow undefined symbols.
2425           allow_undefined_flag="$no_undefined_flag"
2426         fi
2427       fi
2428
2429       if test "$mode" != relink; then
2430         # Remove our outputs.
2431         $show "${rm}r $output_objdir/$outputname $output_objdir/$libname.* $output_objdir/${libname}${release}.*"
2432         $run ${rm}r $output_objdir/$outputname $output_objdir/$libname.* $output_objdir/${libname}${release}.*
2433       fi
2434
2435       # Now set the variables for building old libraries.
2436       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
2437         oldlibs="$oldlibs $output_objdir/$libname.$libext"
2438
2439         # Transform .lo files to .o files.
2440         oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
2441       fi
2442
2443       # Eliminate all temporary directories.
2444       for path in $notinst_path; do
2445         lib_search_path=`echo "$lib_search_path " | ${SED} -e 's% $path % %g'`
2446         deplibs=`echo "$deplibs " | ${SED} -e 's% -L$path % %g'`
2447         dependency_libs=`echo "$dependency_libs " | ${SED} -e 's% -L$path % %g'`
2448       done
2449
2450       if test -n "$xrpath"; then
2451         # If the user specified any rpath flags, then add them.
2452         temp_xrpath=
2453         for libdir in $xrpath; do
2454           temp_xrpath="$temp_xrpath -R$libdir"
2455           case "$finalize_rpath " in
2456           *" $libdir "*) ;;
2457           *) finalize_rpath="$finalize_rpath $libdir" ;;
2458           esac
2459         done
2460         if test $hardcode_into_libs != yes || test $build_old_libs = yes; then
2461           dependency_libs="$temp_xrpath $dependency_libs"
2462         fi
2463       fi
2464
2465       # Make sure dlfiles contains only unique files that won't be dlpreopened
2466       old_dlfiles="$dlfiles"
2467       dlfiles=
2468       for lib in $old_dlfiles; do
2469         case " $dlprefiles $dlfiles " in
2470         *" $lib "*) ;;
2471         *) dlfiles="$dlfiles $lib" ;;
2472         esac
2473       done
2474
2475       # Make sure dlprefiles contains only unique files
2476       old_dlprefiles="$dlprefiles"
2477       dlprefiles=
2478       for lib in $old_dlprefiles; do
2479         case "$dlprefiles " in
2480         *" $lib "*) ;;
2481         *) dlprefiles="$dlprefiles $lib" ;;
2482         esac
2483       done
2484
2485       if test "$build_libtool_libs" = yes; then
2486         if test -n "$rpath"; then
2487           case $host in
2488           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
2489             # these systems don't actually have a c library (as such)!
2490             ;;
2491           *-*-rhapsody* | *-*-darwin1.[012])
2492             # Rhapsody C library is in the System framework
2493             deplibs="$deplibs -framework System"
2494             ;;
2495           *-*-netbsd*)
2496             # Don't link with libc until the a.out ld.so is fixed.
2497             ;;
2498           *-*-openbsd* | *-*-freebsd*)
2499             # Do not include libc due to us having libc/libc_r.
2500             ;;
2501           *)
2502             # Add libc to deplibs on all other systems if necessary.
2503             if test $build_libtool_need_lc = "yes"; then
2504               deplibs="$deplibs -lc"
2505             fi
2506             ;;
2507           esac
2508         fi
2509
2510         # Transform deplibs into only deplibs that can be linked in shared.
2511         name_save=$name
2512         libname_save=$libname
2513         release_save=$release
2514         versuffix_save=$versuffix
2515         major_save=$major
2516         # I'm not sure if I'm treating the release correctly.  I think
2517         # release should show up in the -l (ie -lgmp5) so we don't want to
2518         # add it in twice.  Is that correct?
2519         release=""
2520         versuffix=""
2521         major=""
2522         newdeplibs=
2523         droppeddeps=no
2524         case $deplibs_check_method in
2525         pass_all)
2526           # Don't check for shared/static.  Everything works.
2527           # This might be a little naive.  We might want to check
2528           # whether the library exists or not.  But this is on
2529           # osf3 & osf4 and I'm not really sure... Just
2530           # implementing what was already the behaviour.
2531           newdeplibs=$deplibs
2532           ;;
2533         test_compile)
2534           # This code stresses the "libraries are programs" paradigm to its
2535           # limits. Maybe even breaks it.  We compile a program, linking it
2536           # against the deplibs as a proxy for the library.  Then we can check
2537           # whether they linked in statically or dynamically with ldd.
2538           $rm conftest.c
2539           cat > conftest.c <<EOF
2540           int main() { return 0; }
2541 EOF
2542           $rm conftest
2543           $CC -o conftest conftest.c $deplibs
2544           if test $? -eq 0 ; then
2545             ldd_output=`ldd conftest`
2546             for i in $deplibs; do
2547               name="`expr $i : '-l\(.*\)'`"
2548               # If $name is empty we are operating on a -L argument.
2549               if test -n "$name" && test "$name" != "0"; then
2550                 libname=`eval \\$echo \"$libname_spec\"`
2551                 deplib_matches=`eval \\$echo \"$library_names_spec\"`
2552                 set dummy $deplib_matches
2553                 deplib_match=$2
2554                 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
2555                   newdeplibs="$newdeplibs $i"
2556                 else
2557                   droppeddeps=yes
2558                   echo
2559                   echo "*** Warning: dynamic linker does not accept needed library $i."
2560                   echo "*** I have the capability to make that library automatically link in when"
2561                   echo "*** you link to this library.  But I can only do this if you have a"
2562                   echo "*** shared version of the library, which I believe you do not have"
2563                   echo "*** because a test_compile did reveal that the linker did not use it for"
2564                   echo "*** its dynamic dependency list that programs get resolved with at runtime."
2565                 fi
2566               else
2567                 newdeplibs="$newdeplibs $i"
2568               fi
2569             done
2570           else
2571             # Error occured in the first compile.  Let's try to salvage
2572             # the situation: Compile a separate program for each library.
2573             for i in $deplibs; do
2574               name="`expr $i : '-l\(.*\)'`"
2575              # If $name is empty we are operating on a -L argument.
2576               if test -n "$name" && test "$name" != "0"; then
2577                 $rm conftest
2578                 $CC -o conftest conftest.c $i
2579                 # Did it work?
2580                 if test $? -eq 0 ; then
2581                   ldd_output=`ldd conftest`
2582                   libname=`eval \\$echo \"$libname_spec\"`
2583                   deplib_matches=`eval \\$echo \"$library_names_spec\"`
2584                   set dummy $deplib_matches
2585                   deplib_match=$2
2586                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
2587                     newdeplibs="$newdeplibs $i"
2588                   else
2589                     droppeddeps=yes
2590                     echo
2591                     echo "*** Warning: dynamic linker does not accept needed library $i."
2592                     echo "*** I have the capability to make that library automatically link in when"
2593                     echo "*** you link to this library.  But I can only do this if you have a"
2594                     echo "*** shared version of the library, which you do not appear to have"
2595                     echo "*** because a test_compile did reveal that the linker did not use this one"
2596                     echo "*** as a dynamic dependency that programs can get resolved with at runtime."
2597                   fi
2598                 else
2599                   droppeddeps=yes
2600                   echo
2601                   echo "*** Warning!  Library $i is needed by this library but I was not able to"
2602                   echo "***  make it link in!  You will probably need to install it or some"
2603                   echo "*** library that it depends on before this library will be fully"
2604                   echo "*** functional.  Installing it before continuing would be even better."
2605                 fi
2606               else
2607                 newdeplibs="$newdeplibs $i"
2608               fi
2609             done
2610           fi
2611           ;;
2612         file_magic*)
2613           set dummy $deplibs_check_method
2614           file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2615           for a_deplib in $deplibs; do
2616             name="`expr $a_deplib : '-l\(.*\)'`"
2617             # If $name is empty we are operating on a -L argument.
2618             if test -n "$name" && test "$name" != "0"; then
2619               libname=`eval \\$echo \"$libname_spec\"`
2620               for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
2621                     potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
2622                     for potent_lib in $potential_libs; do
2623                       # Follow soft links.
2624                       if ls -lLd "$potent_lib" 2>/dev/null \
2625                          | grep " -> " >/dev/null; then
2626                         continue
2627                       fi
2628                       # The statement above tries to avoid entering an
2629                       # endless loop below, in case of cyclic links.
2630                       # We might still enter an endless loop, since a link
2631                       # loop can be closed while we follow links,
2632                       # but so what?
2633                       potlib="$potent_lib"
2634                       while test -h "$potlib" 2>/dev/null; do
2635                         potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
2636                         case $potliblink in
2637                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
2638                         *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
2639                         esac
2640                       done
2641                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
2642                          | ${SED} 10q \
2643                          | egrep "$file_magic_regex" > /dev/null; then
2644                         newdeplibs="$newdeplibs $a_deplib"
2645                         a_deplib=""
2646                         break 2
2647                       fi
2648                     done
2649               done
2650               if test -n "$a_deplib" ; then
2651                 droppeddeps=yes
2652                 echo
2653                 echo "*** Warning: linker path does not have real file for library $a_deplib."
2654                 echo "*** I have the capability to make that library automatically link in when"
2655                 echo "*** you link to this library.  But I can only do this if you have a"
2656                 echo "*** shared version of the library, which you do not appear to have"
2657                 echo "*** because I did check the linker path looking for a file starting"
2658                 if test -z "$potlib" ; then
2659                   echo "*** with $libname but no candidates were found. (...for file magic test)"
2660                 else
2661                   echo "*** with $libname and none of the candidates passed a file format test"
2662                   echo "*** using a file magic. Last file checked: $potlib"
2663                 fi
2664               fi
2665             else
2666               # Add a -L argument.
2667               newdeplibs="$newdeplibs $a_deplib"
2668             fi
2669           done # Gone through all deplibs.
2670           ;;
2671         match_pattern*)
2672           set dummy $deplibs_check_method
2673           match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2674           for a_deplib in $deplibs; do
2675             name="`expr $a_deplib : '-l\(.*\)'`"
2676             # If $name is empty we are operating on a -L argument.
2677             if test -n "$name" && test "$name" != "0"; then
2678               libname=`eval \\$echo \"$libname_spec\"`
2679               for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
2680                 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
2681                 for potent_lib in $potential_libs; do
2682                   potlib="$potent_lib" # see symlink-check below in file_magic test
2683                   if eval echo \"$potent_lib\" 2>/dev/null \
2684                       | ${SED} 10q \
2685                       | egrep "$match_pattern_regex" > /dev/null; then
2686                     newdeplibs="$newdeplibs $a_deplib"
2687                     a_deplib=""
2688                     break 2
2689                   fi
2690                 done
2691               done
2692               if test -n "$a_deplib" ; then
2693                 droppeddeps=yes
2694                 echo
2695                 echo "*** Warning: linker path does not have real file for library $a_deplib."
2696                 echo "*** I have the capability to make that library automatically link in when"
2697                 echo "*** you link to this library.  But I can only do this if you have a"
2698                 echo "*** shared version of the library, which you do not appear to have"
2699                 echo "*** because I did check the linker path looking for a file starting"
2700                 if test -z "$potlib" ; then
2701                   echo "*** with $libname but no candidates were found. (...for regex pattern test)"
2702                 else
2703                   echo "*** with $libname and none of the candidates passed a file format test"
2704                   echo "*** using a regex pattern. Last file checked: $potlib"
2705                 fi
2706               fi
2707             else
2708               # Add a -L argument.
2709               newdeplibs="$newdeplibs $a_deplib"
2710             fi
2711           done # Gone through all deplibs.
2712           ;;
2713         none | unknown | *)
2714           newdeplibs=""
2715           if $echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
2716                -e 's/ -[LR][^ ]*//g' -e 's/[    ]//g' |
2717              grep . >/dev/null; then
2718             echo
2719             if test "X$deplibs_check_method" = "Xnone"; then
2720               echo "*** Warning: inter-library dependencies are not supported in this platform."
2721             else
2722               echo "*** Warning: inter-library dependencies are not known to be supported."
2723             fi
2724             echo "*** All declared inter-library dependencies are being dropped."
2725             droppeddeps=yes
2726           fi
2727           ;;
2728         esac
2729         versuffix=$versuffix_save
2730         major=$major_save
2731         release=$release_save
2732         libname=$libname_save
2733         name=$name_save
2734
2735         case $host in
2736         *-*-rhapsody* | *-*-darwin1.[012])
2737           # On Rhapsody replace the C library is the System framework
2738           newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
2739           ;;
2740         esac
2741
2742         if test "$droppeddeps" = yes; then
2743           if test "$module" = yes; then
2744             echo
2745             echo "*** Warning: libtool could not satisfy all declared inter-library"
2746             echo "*** dependencies of module $libname.  Therefore, libtool will create"
2747             echo "*** a static module, that should work as long as the dlopening"
2748             echo "*** application is linked with the -dlopen flag."
2749             if test -z "$global_symbol_pipe"; then
2750               echo
2751               echo "*** However, this would only work if libtool was able to extract symbol"
2752               echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2753               echo "*** not find such a program.  So, this module is probably useless."
2754               echo "*** \`nm' from GNU binutils and a full rebuild may help."
2755             fi
2756             if test "$build_old_libs" = no; then
2757               oldlibs="$output_objdir/$libname.$libext"
2758               build_libtool_libs=module
2759               build_old_libs=yes
2760             else
2761               build_libtool_libs=no
2762             fi
2763           else
2764             echo "*** The inter-library dependencies that have been dropped here will be"
2765             echo "*** automatically added whenever a program is linked with this library"
2766             echo "*** or is declared to -dlopen it."
2767
2768             if test $allow_undefined = no; then
2769               echo
2770               echo "*** Since this library must not contain undefined symbols,"
2771               echo "*** because either the platform does not support them or"
2772               echo "*** it was explicitly requested with -no-undefined,"
2773               echo "*** libtool will only create a static version of it."
2774               if test "$build_old_libs" = no; then
2775                 oldlibs="$output_objdir/$libname.$libext"
2776                 build_libtool_libs=module
2777                 build_old_libs=yes
2778               else
2779                 build_libtool_libs=no
2780               fi
2781             fi
2782           fi
2783         fi
2784         # Done checking deplibs!
2785         deplibs=$newdeplibs
2786       fi
2787
2788       # All the library-specific variables (install_libdir is set above).
2789       library_names=
2790       old_library=
2791       dlname=
2792
2793       # Test again, we may have decided not to build it any more
2794       if test "$build_libtool_libs" = yes; then
2795         if test $hardcode_into_libs = yes; then
2796           # Hardcode the library paths
2797           hardcode_libdirs=
2798           dep_rpath=
2799           rpath="$finalize_rpath"
2800           test "$mode" != relink && rpath="$compile_rpath$rpath"
2801           for libdir in $rpath; do
2802             if test -n "$hardcode_libdir_flag_spec"; then
2803               if test -n "$hardcode_libdir_separator"; then
2804                 if test -z "$hardcode_libdirs"; then
2805                   hardcode_libdirs="$libdir"
2806                 else
2807                   # Just accumulate the unique libdirs.
2808                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
2809                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
2810                     ;;
2811                   *)
2812                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
2813                     ;;
2814                   esac
2815                 fi
2816               else
2817                 eval flag=\"$hardcode_libdir_flag_spec\"
2818                 dep_rpath="$dep_rpath $flag"
2819               fi
2820             elif test -n "$runpath_var"; then
2821               case "$perm_rpath " in
2822               *" $libdir "*) ;;
2823               *) perm_rpath="$perm_rpath $libdir" ;;
2824               esac
2825             fi
2826           done
2827           # Substitute the hardcoded libdirs into the rpath.
2828           if test -n "$hardcode_libdir_separator" &&
2829              test -n "$hardcode_libdirs"; then
2830             libdir="$hardcode_libdirs"
2831             eval dep_rpath=\"$hardcode_libdir_flag_spec\"
2832           fi
2833           if test -n "$runpath_var" && test -n "$perm_rpath"; then
2834             # We should set the runpath_var.
2835             rpath=
2836             for dir in $perm_rpath; do
2837               rpath="$rpath$dir:"
2838             done
2839             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
2840           fi
2841           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
2842         fi
2843
2844         shlibpath="$finalize_shlibpath"
2845         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
2846         if test -n "$shlibpath"; then
2847           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
2848         fi
2849
2850         # Get the real and link names of the library.
2851         eval library_names=\"$library_names_spec\"
2852         set dummy $library_names
2853         realname="$2"
2854         shift; shift
2855
2856         if test -n "$soname_spec"; then
2857           eval soname=\"$soname_spec\"
2858         else
2859           soname="$realname"
2860         fi
2861         test -z "$dlname" && dlname=$soname
2862
2863         lib="$output_objdir/$realname"
2864         for link
2865         do
2866           linknames="$linknames $link"
2867         done
2868
2869         # Ensure that we have .o objects for linkers which dislike .lo
2870         # (e.g. aix) in case we are running --disable-static
2871         for obj in $libobjs; do
2872           xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
2873           if test "X$xdir" = "X$obj"; then
2874             xdir="."
2875           else
2876             xdir="$xdir"
2877           fi
2878           baseobj=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
2879           oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
2880           if test ! -f $xdir/$oldobj; then
2881             $show "(cd $xdir && ${LN_S} $baseobj $oldobj)"
2882             $run eval '(cd $xdir && ${LN_S} $baseobj $oldobj)' || exit $?
2883           fi
2884         done
2885
2886         # Use standard objects if they are pic
2887         test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2888
2889         # Prepare the list of exported symbols
2890         if test -z "$export_symbols"; then
2891           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
2892             $show "generating symbol list for \`$libname.la'"
2893             export_symbols="$output_objdir/$libname.exp"
2894             $run $rm $export_symbols
2895             eval cmds=\"$export_symbols_cmds\"
2896             save_ifs="$IFS"; IFS='~'
2897             for cmd in $cmds; do
2898               IFS="$save_ifs"
2899               $show "$cmd"
2900               $run eval "$cmd" || exit $?
2901             done
2902             IFS="$save_ifs"
2903             if test -n "$export_symbols_regex"; then
2904               $show "egrep -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
2905               $run eval 'egrep -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
2906               $show "$mv \"${export_symbols}T\" \"$export_symbols\""
2907               $run eval '$mv "${export_symbols}T" "$export_symbols"'
2908             fi
2909           fi
2910         fi
2911
2912         if test -n "$export_symbols" && test -n "$include_expsyms"; then
2913           $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
2914         fi
2915
2916         if test -n "$convenience"; then
2917           if test -n "$whole_archive_flag_spec"; then
2918             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
2919           else
2920             gentop="$output_objdir/${outputname}x"
2921             $show "${rm}r $gentop"
2922             $run ${rm}r "$gentop"
2923             $show "mkdir $gentop"
2924             $run mkdir "$gentop"
2925             status=$?
2926             if test $status -ne 0 && test ! -d "$gentop"; then
2927               exit $status
2928             fi
2929             generated="$generated $gentop"
2930
2931             for xlib in $convenience; do
2932               # Extract the objects.
2933               case $xlib in
2934               [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
2935               *) xabs=`pwd`"/$xlib" ;;
2936               esac
2937               xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
2938               xdir="$gentop/$xlib"
2939
2940               $show "${rm}r $xdir"
2941               $run ${rm}r "$xdir"
2942               $show "mkdir $xdir"
2943               $run mkdir "$xdir"
2944               status=$?
2945               if test $status -ne 0 && test ! -d "$xdir"; then
2946                 exit $status
2947               fi
2948               $show "(cd $xdir && $AR x $xabs)"
2949               $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
2950
2951               libobjs="$libobjs "`find $xdir -name \*.o -print -o -name \*.lo -print | $NL2SP`
2952             done
2953           fi
2954         fi
2955
2956         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
2957           eval flag=\"$thread_safe_flag_spec\"
2958           linker_flags="$linker_flags $flag"
2959         fi
2960
2961         # Make a backup of the uninstalled library when relinking
2962         if test "$mode" = relink; then
2963           $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
2964         fi
2965
2966         # Do each of the archive commands.
2967         if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
2968           eval cmds=\"$archive_expsym_cmds\"
2969         else
2970           save_deplibs="$deplibs"
2971           for conv in $convenience; do
2972             tmp_deplibs=
2973             for test_deplib in $deplibs; do
2974               if test "$test_deplib" != "$conv"; then
2975                 tmp_deplibs="$tmp_deplibs $test_deplib"
2976               fi
2977             done
2978             deplibs="$tmp_deplibs"
2979           done
2980           eval cmds=\"$archive_cmds\"
2981           deplibs="$save_deplibs"
2982         fi
2983         save_ifs="$IFS"; IFS='~'
2984         for cmd in $cmds; do
2985           IFS="$save_ifs"
2986           $show "$cmd"
2987           $run eval "$cmd" || exit $?
2988         done
2989         IFS="$save_ifs"
2990
2991         # Restore the uninstalled library and exit
2992         if test "$mode" = relink; then
2993           $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
2994           exit 0
2995         fi
2996
2997         # Create links to the real library.
2998         for linkname in $linknames; do
2999           if test "$realname" != "$linkname"; then
3000             $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
3001             $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
3002           fi
3003         done
3004
3005         # If -module or -export-dynamic was specified, set the dlname.
3006         if test "$module" = yes || test "$export_dynamic" = yes; then
3007           # On all known operating systems, these are identical.
3008           dlname="$soname"
3009         fi
3010       fi
3011       ;;
3012
3013     obj)
3014       if test -n "$deplibs"; then
3015         $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
3016       fi
3017
3018       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3019         $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
3020       fi
3021
3022       if test -n "$rpath"; then
3023         $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
3024       fi
3025
3026       if test -n "$xrpath"; then
3027         $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
3028       fi
3029
3030       if test -n "$vinfo"; then
3031         $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
3032       fi
3033
3034       if test -n "$release"; then
3035         $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
3036       fi
3037
3038       case $output in
3039       *.lo)
3040         if test -n "$objs$old_deplibs"; then
3041           $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
3042           exit 1
3043         fi
3044         libobj="$output"
3045         obj=`$echo "X$output" | $Xsed -e "$lo2o"`
3046         ;;
3047       *)
3048         libobj=
3049         obj="$output"
3050         ;;
3051       esac
3052
3053       # Delete the old objects.
3054       $run $rm $obj $libobj
3055
3056       # Objects from convenience libraries.  This assumes
3057       # single-version convenience libraries.  Whenever we create
3058       # different ones for PIC/non-PIC, this we'll have to duplicate
3059       # the extraction.
3060       reload_conv_objs=
3061       gentop=
3062       # reload_cmds runs $LD directly, so let us get rid of
3063       # -Wl from whole_archive_flag_spec
3064       wl=
3065
3066       if test -n "$convenience"; then
3067         if test -n "$whole_archive_flag_spec"; then
3068           eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
3069         else
3070           gentop="$output_objdir/${obj}x"
3071           $show "${rm}r $gentop"
3072           $run ${rm}r "$gentop"
3073           $show "mkdir $gentop"
3074           $run mkdir "$gentop"
3075           status=$?
3076           if test $status -ne 0 && test ! -d "$gentop"; then
3077             exit $status
3078           fi
3079           generated="$generated $gentop"
3080
3081           for xlib in $convenience; do
3082             # Extract the objects.
3083             case $xlib in
3084             [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3085             *) xabs=`pwd`"/$xlib" ;;
3086             esac
3087             xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3088             xdir="$gentop/$xlib"
3089
3090             $show "${rm}r $xdir"
3091             $run ${rm}r "$xdir"
3092             $show "mkdir $xdir"
3093             $run mkdir "$xdir"
3094             status=$?
3095             if test $status -ne 0 && test ! -d "$xdir"; then
3096               exit $status
3097             fi
3098             $show "(cd $xdir && $AR x $xabs)"
3099             $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3100
3101             reload_conv_objs="$reload_objs "`find $xdir -name \*.o -print -o -name \*.lo -print | $NL2SP`
3102           done
3103         fi
3104       fi
3105
3106       # Create the old-style object.
3107       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
3108
3109       output="$obj"
3110       eval cmds=\"$reload_cmds\"
3111       save_ifs="$IFS"; IFS='~'
3112       for cmd in $cmds; do
3113         IFS="$save_ifs"
3114         $show "$cmd"
3115         $run eval "$cmd" || exit $?
3116       done
3117       IFS="$save_ifs"
3118
3119       # Exit if we aren't doing a library object file.
3120       if test -z "$libobj"; then
3121         if test -n "$gentop"; then
3122           $show "${rm}r $gentop"
3123           $run ${rm}r $gentop
3124         fi
3125
3126         exit 0
3127       fi
3128
3129       if test "$build_libtool_libs" != yes; then
3130         if test -n "$gentop"; then
3131           $show "${rm}r $gentop"
3132           $run ${rm}r $gentop
3133         fi
3134
3135         # Create an invalid libtool object if no PIC, so that we don't
3136         # accidentally link it into a program.
3137         $show "echo timestamp > $libobj"
3138         $run eval "echo timestamp > $libobj" || exit $?
3139         exit 0
3140       fi
3141
3142       if test -n "$pic_flag" || test "$pic_mode" != default; then
3143         # Only do commands if we really have different PIC objects.
3144         reload_objs="$libobjs $reload_conv_objs"
3145         output="$libobj"
3146         eval cmds=\"$reload_cmds\"
3147         save_ifs="$IFS"; IFS='~'
3148         for cmd in $cmds; do
3149           IFS="$save_ifs"
3150           $show "$cmd"
3151           $run eval "$cmd" || exit $?
3152         done
3153         IFS="$save_ifs"
3154       else
3155         # Just create a symlink.
3156         $show $rm $libobj
3157         $run $rm $libobj
3158         xdir=`$echo "X$libobj" | $Xsed -e 's%/[^/]*$%%'`
3159         if test "X$xdir" = "X$libobj"; then
3160           xdir="."
3161         else
3162           xdir="$xdir"
3163         fi
3164         baseobj=`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`
3165         oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
3166         $show "(cd $xdir && $LN_S $oldobj $baseobj)"
3167         $run eval '(cd $xdir && $LN_S $oldobj $baseobj)' || exit $?
3168       fi
3169
3170       if test -n "$gentop"; then
3171         $show "${rm}r $gentop"
3172         $run ${rm}r $gentop
3173       fi
3174
3175       exit 0
3176       ;;
3177
3178     prog)
3179       case $host in
3180         *cygwin*) output=`echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
3181       esac
3182       if test -n "$vinfo"; then
3183         $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
3184       fi
3185
3186       if test -n "$release"; then
3187         $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
3188       fi
3189
3190       if test "$preload" = yes; then
3191         if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
3192            test "$dlopen_self_static" = unknown; then
3193           $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
3194         fi
3195       fi
3196
3197       case $host in
3198       *-*-rhapsody* | *-*-darwin1.[012])
3199         # On Rhapsody replace the C library is the System framework
3200         compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
3201         finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
3202         case $host in
3203         *darwin*)
3204           # Don't allow lazy linking, it breaks C++ global constructors
3205           compile_command="$compile_command ${wl}-bind_at_load"
3206           finalize_command="$finalize_command ${wl}-bind_at_load"
3207           ;;
3208         esac
3209         ;;
3210       esac
3211
3212       compile_command="$compile_command $compile_deplibs"
3213       finalize_command="$finalize_command $finalize_deplibs"
3214
3215       if test -n "$rpath$xrpath"; then
3216         # If the user specified any rpath flags, then add them.
3217         for libdir in $rpath $xrpath; do
3218           # This is the magic to use -rpath.
3219           case "$finalize_rpath " in
3220           *" $libdir "*) ;;
3221           *) finalize_rpath="$finalize_rpath $libdir" ;;
3222           esac
3223         done
3224       fi
3225
3226       # Now hardcode the library paths
3227       rpath=
3228       hardcode_libdirs=
3229       for libdir in $compile_rpath $finalize_rpath; do
3230         if test -n "$hardcode_libdir_flag_spec"; then
3231           if test -n "$hardcode_libdir_separator"; then
3232             if test -z "$hardcode_libdirs"; then
3233               hardcode_libdirs="$libdir"
3234             else
3235               # Just accumulate the unique libdirs.
3236               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3237               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3238                 ;;
3239               *)
3240                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3241                 ;;
3242               esac
3243             fi
3244           else
3245             eval flag=\"$hardcode_libdir_flag_spec\"
3246             rpath="$rpath $flag"
3247           fi
3248         elif test -n "$runpath_var"; then
3249           case "$perm_rpath " in
3250           *" $libdir "*) ;;
3251           *) perm_rpath="$perm_rpath $libdir" ;;
3252           esac
3253         fi
3254         case $host in
3255         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
3256           case :$dllsearchpath: in
3257           *":$libdir:"*) ;;
3258           *) dllsearchpath="$dllsearchpath:$libdir";;
3259           esac
3260           ;;
3261         esac
3262       done
3263       # Substitute the hardcoded libdirs into the rpath.
3264       if test -n "$hardcode_libdir_separator" &&
3265          test -n "$hardcode_libdirs"; then
3266         libdir="$hardcode_libdirs"
3267         eval rpath=\" $hardcode_libdir_flag_spec\"
3268       fi
3269       compile_rpath="$rpath"
3270
3271       rpath=
3272       hardcode_libdirs=
3273       for libdir in $finalize_rpath; do
3274         if test -n "$hardcode_libdir_flag_spec"; then
3275           if test -n "$hardcode_libdir_separator"; then
3276             if test -z "$hardcode_libdirs"; then
3277               hardcode_libdirs="$libdir"
3278             else
3279               # Just accumulate the unique libdirs.
3280               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3281               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3282                 ;;
3283               *)
3284                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3285                 ;;
3286               esac
3287             fi
3288           else
3289             eval flag=\"$hardcode_libdir_flag_spec\"
3290             rpath="$rpath $flag"
3291           fi
3292         elif test -n "$runpath_var"; then
3293           case "$finalize_perm_rpath " in
3294           *" $libdir "*) ;;
3295           *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
3296           esac
3297         fi
3298       done
3299       # Substitute the hardcoded libdirs into the rpath.
3300       if test -n "$hardcode_libdir_separator" &&
3301          test -n "$hardcode_libdirs"; then
3302         libdir="$hardcode_libdirs"
3303         eval rpath=\" $hardcode_libdir_flag_spec\"
3304       fi
3305       finalize_rpath="$rpath"
3306
3307       if test -n "$libobjs" && test "$build_old_libs" = yes; then
3308         # Transform all the library objects into standard objects.
3309         compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3310         finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3311       fi
3312
3313       dlsyms=
3314       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3315         if test -n "$NM" && test -n "$global_symbol_pipe"; then
3316           dlsyms="${outputname}S.c"
3317         else
3318           $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
3319         fi
3320       fi
3321
3322       if test -n "$dlsyms"; then
3323         case $dlsyms in
3324         "") ;;
3325         *.c)
3326           # Discover the nlist of each of the dlfiles.
3327           nlist="$output_objdir/${outputname}.nm"
3328
3329           $show "$rm $nlist ${nlist}S ${nlist}T"
3330           $run $rm "$nlist" "${nlist}S" "${nlist}T"
3331
3332           # Parse the name list into a source file.
3333           $show "creating $output_objdir/$dlsyms"
3334
3335           test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
3336 /* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
3337 /* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
3338
3339 #ifdef __cplusplus
3340 extern \"C\" {
3341 #endif
3342
3343 /* Prevent the only kind of declaration conflicts we can make. */
3344 #define lt_preloaded_symbols some_other_symbol
3345
3346 /* External symbol declarations for the compiler. */\
3347 "
3348
3349           if test "$dlself" = yes; then
3350             $show "generating symbol list for \`$output'"
3351
3352             test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
3353
3354             # Add our own program objects to the symbol list.
3355             progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3356             for arg in $progfiles; do
3357               $show "extracting global C symbols from \`$arg'"
3358               $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
3359             done
3360
3361             if test -n "$exclude_expsyms"; then
3362               $run eval 'egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3363               $run eval '$mv "$nlist"T "$nlist"'
3364             fi
3365
3366             if test -n "$export_symbols_regex"; then
3367               $run eval 'egrep -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3368               $run eval '$mv "$nlist"T "$nlist"'
3369             fi
3370
3371             # Prepare the list of exported symbols
3372             if test -z "$export_symbols"; then
3373               export_symbols="$output_objdir/$output.exp"
3374               $run $rm $export_symbols
3375               $run eval "${SED} -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3376             else
3377               $run eval "${SED} -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
3378               $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
3379               $run eval 'mv "$nlist"T "$nlist"'
3380             fi
3381           fi
3382
3383           for arg in $dlprefiles; do
3384             $show "extracting global C symbols from \`$arg'"
3385             name=`echo "$arg" | ${SED} -e 's%^.*/%%'`
3386             $run eval 'echo ": $name " >> "$nlist"'
3387             $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
3388           done
3389
3390           if test -z "$run"; then
3391             # Make sure we have at least an empty file.
3392             test -f "$nlist" || : > "$nlist"
3393
3394             if test -n "$exclude_expsyms"; then
3395               egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3396               $mv "$nlist"T "$nlist"
3397             fi
3398
3399             # Try sorting and uniquifying the output.
3400             if grep -v "^: " < "$nlist" |
3401                 if sort -k 3 </dev/null >/dev/null 2>&1; then
3402                   sort -k 3
3403                 else
3404                   sort +2
3405                 fi |
3406                 uniq > "$nlist"S; then
3407               :
3408             else
3409               grep -v "^: " < "$nlist" > "$nlist"S
3410             fi
3411
3412             if test -f "$nlist"S; then
3413               eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
3414             else
3415               echo '/* NONE */' >> "$output_objdir/$dlsyms"
3416             fi
3417
3418             $echo >> "$output_objdir/$dlsyms" "\
3419
3420 #undef lt_preloaded_symbols
3421
3422 #if defined (__STDC__) && __STDC__
3423 # define lt_ptr void *
3424 #else
3425 # define lt_ptr char *
3426 # define const
3427 #endif
3428
3429 /* The mapping between symbol names and symbols. */
3430 const struct {
3431   const char *name;
3432   lt_ptr address;
3433 }
3434 lt_preloaded_symbols[] =
3435 {\
3436 "
3437
3438             eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
3439
3440             $echo >> "$output_objdir/$dlsyms" "\
3441   {0, (lt_ptr) 0}
3442 };
3443
3444 /* This works around a problem in FreeBSD linker */
3445 #ifdef FREEBSD_WORKAROUND
3446 static const void *lt_preloaded_setup() {
3447   return lt_preloaded_symbols;
3448 }
3449 #endif
3450
3451 #ifdef __cplusplus
3452 }
3453 #endif\
3454 "
3455           fi
3456
3457           pic_flag_for_symtable=
3458           case $host in
3459           # compiling the symbol table file with pic_flag works around
3460           # a FreeBSD bug that causes programs to crash when -lm is
3461           # linked before any other PIC object.  But we must not use
3462           # pic_flag when linking with -static.  The problem exists in
3463           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3464           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3465             case "$compile_command " in
3466             *" -static "*) ;;
3467             *) pic_flag_for_symtable=" $pic_flag -DPIC -DFREEBSD_WORKAROUND";;
3468             esac;;
3469           *-*-hpux*)
3470             case "$compile_command " in
3471             *" -static "*) ;;
3472             *) pic_flag_for_symtable=" $pic_flag -DPIC";;
3473             esac
3474           esac
3475
3476           # Now compile the dynamic symbol file.
3477           $show "(cd $output_objdir && $CC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
3478           $run eval '(cd $output_objdir && $CC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
3479
3480           # Clean up the generated files.
3481           $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
3482           $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
3483
3484           # Transform the symbol file into the correct name.
3485           compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
3486           finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
3487           ;;
3488         *)
3489           $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
3490           exit 1
3491           ;;
3492         esac
3493       else
3494         # We keep going just in case the user didn't refer to
3495         # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
3496         # really was required.
3497
3498         # Nullify the symbol file.
3499         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
3500         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
3501       fi
3502
3503       if test $need_relink = no || test "$build_libtool_libs" != yes; then
3504         # Replace the output file specification.
3505         compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
3506         link_command="$compile_command$compile_rpath"
3507
3508         # We have no uninstalled library dependencies, so finalize right now.
3509         $show "$link_command"
3510         $run eval "$link_command"
3511         status=$?
3512
3513         # Delete the generated files.
3514         if test -n "$dlsyms"; then
3515           $show "$rm $output_objdir/${outputname}S.${objext}"
3516           $run $rm "$output_objdir/${outputname}S.${objext}"
3517         fi
3518
3519         exit $status
3520       fi
3521
3522       if test -n "$shlibpath_var"; then
3523         # We should set the shlibpath_var
3524         rpath=
3525         for dir in $temp_rpath; do
3526           case $dir in
3527           [\\/]* | [A-Za-z]:[\\/]*)
3528             # Absolute path.
3529             rpath="$rpath$dir:"
3530             ;;
3531           *)
3532             # Relative path: add a thisdir entry.
3533             rpath="$rpath\$thisdir/$dir:"
3534             ;;
3535           esac
3536         done
3537         temp_rpath="$rpath"
3538       fi
3539
3540       if test -n "$compile_shlibpath$finalize_shlibpath"; then
3541         compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
3542       fi
3543       if test -n "$finalize_shlibpath"; then
3544         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
3545       fi
3546
3547       compile_var=
3548       finalize_var=
3549       if test -n "$runpath_var"; then
3550         if test -n "$perm_rpath"; then
3551           # We should set the runpath_var.
3552           rpath=
3553           for dir in $perm_rpath; do
3554             rpath="$rpath$dir:"
3555           done
3556           compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
3557         fi
3558         if test -n "$finalize_perm_rpath"; then
3559           # We should set the runpath_var.
3560           rpath=
3561           for dir in $finalize_perm_rpath; do
3562             rpath="$rpath$dir:"
3563           done
3564           finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
3565         fi
3566       fi
3567
3568       if test "$no_install" = yes; then
3569         # We don't need to create a wrapper script.
3570         link_command="$compile_var$compile_command$compile_rpath"
3571         # Replace the output file specification.
3572         link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
3573         # Delete the old output file.
3574         $run $rm $output
3575         # Link the executable and exit
3576         $show "$link_command"
3577         $run eval "$link_command" || exit $?
3578         exit 0
3579       fi
3580
3581       if test "$hardcode_action" = relink; then
3582         # Fast installation is not supported
3583         link_command="$compile_var$compile_command$compile_rpath"
3584         relink_command="$finalize_var$finalize_command$finalize_rpath"
3585
3586         $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
3587         $echo "$modename: \`$output' will be relinked during installation" 1>&2
3588       else
3589         if test "$fast_install" != no; then
3590           link_command="$finalize_var$compile_command$finalize_rpath"
3591           if test "$fast_install" = yes; then
3592             relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
3593           else
3594             # fast_install is set to needless
3595             relink_command=
3596           fi
3597         else
3598           link_command="$compile_var$compile_command$compile_rpath"
3599           relink_command="$finalize_var$finalize_command$finalize_rpath"
3600         fi
3601       fi
3602
3603       # Replace the output file specification.
3604       link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
3605
3606       # Delete the old output files.
3607       $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
3608
3609       $show "$link_command"
3610       $run eval "$link_command" || exit $?
3611
3612       # Now create the wrapper script.
3613       $show "creating $output"
3614
3615       # Quote the relink command for shipping.
3616       if test -n "$relink_command"; then
3617         # Preserve any variables that may affect compiler behavior
3618         for var in $variables_saved_for_relink; do
3619           if eval test -z \"\${$var+set}\"; then
3620             relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
3621           elif eval var_value=\$$var; test -z "$var_value"; then
3622             relink_command="$var=; export $var; $relink_command"
3623           else
3624             var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
3625             relink_command="$var=\"$var_value\"; export $var; $relink_command"
3626           fi
3627         done
3628         relink_command="(cd `pwd`; $relink_command)"
3629         relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
3630       fi
3631
3632       # Quote $echo for shipping.
3633       if test "X$echo" = "X$SHELL $0 --fallback-echo"; then
3634         case $0 in
3635         [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $0 --fallback-echo";;
3636         *) qecho="$SHELL `pwd`/$0 --fallback-echo";;
3637         esac
3638         qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
3639       else
3640         qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
3641       fi
3642
3643       # Only actually do things if our run command is non-null.
3644       if test -z "$run"; then
3645         # win32 will think the script is a binary if it has
3646         # a .exe suffix, so we strip it off here.
3647         case $output in
3648           *.exe) output=`echo $output|${SED} 's,.exe$,,'` ;;
3649         esac
3650         # test for cygwin because mv fails w/o .exe extensions
3651         case $host in
3652           *cygwin*) exeext=.exe ;;
3653           *) exeext= ;;
3654         esac
3655         $rm $output
3656         trap "$rm $output; exit 1" 1 2 15
3657
3658         $echo > $output "\
3659 #! $SHELL
3660
3661 # $output - temporary wrapper script for $objdir/$outputname
3662 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
3663 #
3664 # The $output program cannot be directly executed until all the libtool
3665 # libraries that it depends on are installed.
3666 #
3667 # This wrapper script should never be moved out of the build directory.
3668 # If it is, it will not operate correctly.
3669
3670 # Sed substitution that helps us do robust quoting.  It backslashifies
3671 # metacharacters that are still active within double-quoted strings.
3672 Xsed="${SED}"' -e 1s/^X//'
3673 sed_quote_subst='$sed_quote_subst'
3674
3675 # The HP-UX ksh and POSIX shell print the target directory to stdout
3676 # if CDPATH is set.
3677 if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi
3678
3679 relink_command=\"$relink_command\"
3680
3681 # This environment variable determines our operation mode.
3682 if test \"\$libtool_install_magic\" = \"$magic\"; then
3683   # install mode needs the following variable:
3684   notinst_deplibs='$notinst_deplibs'
3685 else
3686   # When we are sourced in execute mode, \$file and \$echo are already set.
3687   if test \"\$libtool_execute_magic\" != \"$magic\"; then
3688     echo=\"$qecho\"
3689     file=\"\$0\"
3690     # Make sure echo works.
3691     if test \"X\$1\" = X--no-reexec; then
3692       # Discard the --no-reexec flag, and continue.
3693       shift
3694     elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
3695       # Yippee, \$echo works!
3696       :
3697     else
3698       # Restart under the correct shell, and then maybe \$echo will work.
3699       exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
3700     fi
3701   fi\
3702 "
3703         $echo >> $output "\
3704
3705   # Find the directory that this script lives in.
3706   thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
3707   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
3708
3709   # Follow symbolic links until we get to the real thisdir.
3710   file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
3711   while test -n \"\$file\"; do
3712     destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
3713
3714     # If there was a directory component, then change thisdir.
3715     if test \"x\$destdir\" != \"x\$file\"; then
3716       case \"\$destdir\" in
3717       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
3718       *) thisdir=\"\$thisdir/\$destdir\" ;;
3719       esac
3720     fi
3721
3722     file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
3723     file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
3724   done
3725
3726   # Try to get the absolute directory name.
3727   absdir=\`cd \"\$thisdir\" && pwd\`
3728   test -n \"\$absdir\" && thisdir=\"\$absdir\"
3729 "
3730
3731         if test "$fast_install" = yes; then
3732           echo >> $output "\
3733   program=lt-'$outputname'$exeext
3734   progdir=\"\$thisdir/$objdir\"
3735
3736   if test ! -f \"\$progdir/\$program\" || \\
3737      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
3738        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
3739
3740     file=\"\$\$-\$program\"
3741
3742     if test ! -d \"\$progdir\"; then
3743       $mkdir \"\$progdir\"
3744     else
3745       $rm \"\$progdir/\$file\"
3746     fi"
3747
3748           echo >> $output "\
3749
3750     # relink executable if necessary
3751     if test -n \"\$relink_command\"; then
3752       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
3753       else
3754         $echo \"\$relink_command_output\" >&2
3755         $rm \"\$progdir/\$file\"
3756         exit 1
3757       fi
3758     fi
3759
3760     $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
3761     { $rm \"\$progdir/\$program\";
3762       $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
3763     $rm \"\$progdir/\$file\"
3764   fi"
3765         else
3766           echo >> $output "\
3767   program='$outputname'
3768   progdir=\"\$thisdir/$objdir\"
3769 "
3770         fi
3771
3772         echo >> $output "\
3773
3774   if test -f \"\$progdir/\$program\"; then"
3775
3776         # Export our shlibpath_var if we have one.
3777         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3778           $echo >> $output "\
3779     # Add our own library path to $shlibpath_var
3780     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
3781
3782     # Some systems cannot cope with colon-terminated $shlibpath_var
3783     # The second colon is a workaround for a bug in BeOS R4 ${SED}
3784     $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
3785
3786     export $shlibpath_var
3787 "
3788         fi
3789
3790         # fixup the dll searchpath if we need to.
3791         if test -n "$dllsearchpath"; then
3792           $echo >> $output "\
3793     # Add the dll search path components to the executable PATH
3794     PATH=$dllsearchpath:\$PATH
3795 "
3796         fi
3797
3798         $echo >> $output "\
3799     if test \"\$libtool_execute_magic\" != \"$magic\"; then
3800       # Run the actual program with our arguments.
3801 "
3802         case $host in
3803         # win32 systems need to use the prog path for dll
3804         # lookup to work
3805         *-*-cygwin* | *-*-pw32*)
3806           $echo >> $output "\
3807       exec \$progdir/\$program \${1+\"\$@\"}
3808 "
3809           ;;
3810
3811         # Backslashes separate directories on plain windows
3812         *-*-mingw | *-*-os2*)
3813           $echo >> $output "\
3814       exec \$progdir\\\\\$program \${1+\"\$@\"}
3815 "
3816           ;;
3817
3818         *)
3819           $echo >> $output "\
3820       # Export the path to the program.
3821       PATH=\"\$progdir:\$PATH\"
3822       export PATH
3823
3824       exec \$program \${1+\"\$@\"}
3825 "
3826           ;;
3827         esac
3828         $echo >> $output "\
3829       \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
3830       exit 1
3831     fi
3832   else
3833     # The program doesn't exist.
3834     \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
3835     \$echo \"This script is just a wrapper for \$program.\" 1>&2
3836     echo \"See the $PACKAGE documentation for more information.\" 1>&2
3837     exit 1
3838   fi
3839 fi\
3840 "
3841         chmod +x $output
3842       fi
3843       exit 0
3844       ;;
3845     esac
3846
3847     # See if we need to build an old-fashioned archive.
3848     for oldlib in $oldlibs; do
3849
3850       if test "$build_libtool_libs" = convenience; then
3851         oldobjs="$libobjs_save"
3852         addlibs="$convenience"
3853         build_libtool_libs=no
3854       else
3855         if test "$build_libtool_libs" = module; then
3856           oldobjs="$libobjs_save"
3857           build_libtool_libs=no
3858         else
3859           oldobjs="$objs$old_deplibs "`$echo "X$libobjs_save" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`
3860         fi
3861         addlibs="$old_convenience"
3862       fi
3863
3864       if test -n "$addlibs"; then
3865         gentop="$output_objdir/${outputname}x"
3866         $show "${rm}r $gentop"
3867         $run ${rm}r "$gentop"
3868         $show "mkdir $gentop"
3869         $run mkdir "$gentop"
3870         status=$?
3871         if test $status -ne 0 && test ! -d "$gentop"; then
3872           exit $status
3873         fi
3874         generated="$generated $gentop"
3875
3876         # Add in members from convenience archives.
3877         for xlib in $addlibs; do
3878           # Extract the objects.
3879           case $xlib in
3880           [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3881           *) xabs=`pwd`"/$xlib" ;;
3882           esac
3883           xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3884           xdir="$gentop/$xlib"
3885
3886           $show "${rm}r $xdir"
3887           $run ${rm}r "$xdir"
3888           $show "mkdir $xdir"
3889           $run mkdir "$xdir"
3890           status=$?
3891           if test $status -ne 0 && test ! -d "$xdir"; then
3892             exit $status
3893           fi
3894           $show "(cd $xdir && $AR x $xabs)"
3895           $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3896
3897           oldobjs="$oldobjs "`find $xdir -name \*.${objext} -print -o -name \*.lo -print | $NL2SP`
3898         done
3899       fi
3900
3901       # Do each command in the archive commands.
3902       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
3903         eval cmds=\"$old_archive_from_new_cmds\"
3904       else
3905         # Ensure that we have .o objects in place in case we decided
3906         # not to build a shared library, and have fallen back to building
3907         # static libs even though --disable-static was passed!
3908         for oldobj in $oldobjs; do
3909           if test ! -f $oldobj; then
3910             xdir=`$echo "X$oldobj" | $Xsed -e 's%/[^/]*$%%'`
3911             if test "X$xdir" = "X$oldobj"; then
3912               xdir="."
3913             else
3914               xdir="$xdir"
3915             fi
3916             baseobj=`$echo "X$oldobj" | $Xsed -e 's%^.*/%%'`
3917             obj=`$echo "X$baseobj" | $Xsed -e "$o2lo"`
3918             $show "(cd $xdir && ${LN_S} $obj $baseobj)"
3919             $run eval '(cd $xdir && ${LN_S} $obj $baseobj)' || exit $?
3920           fi
3921         done
3922
3923         eval cmds=\"$old_archive_cmds\"
3924       fi
3925       save_ifs="$IFS"; IFS='~'
3926       for cmd in $cmds; do
3927         IFS="$save_ifs"
3928         $show "$cmd"
3929         $run eval "$cmd" || exit $?
3930       done
3931       IFS="$save_ifs"
3932     done
3933
3934     if test -n "$generated"; then
3935       $show "${rm}r$generated"
3936       $run ${rm}r$generated
3937     fi
3938
3939     # Now create the libtool archive.
3940     case $output in
3941     *.la)
3942       old_library=
3943       test "$build_old_libs" = yes && old_library="$libname.$libext"
3944       $show "creating $output"
3945
3946       # Preserve any variables that may affect compiler behavior
3947       for var in $variables_saved_for_relink; do
3948         if eval test -z \"\${$var+set}\"; then
3949           relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
3950         elif eval var_value=\$$var; test -z "$var_value"; then
3951           relink_command="$var=; export $var; $relink_command"
3952         else
3953           var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
3954           relink_command="$var=\"$var_value\"; export $var; $relink_command"
3955         fi
3956       done
3957       # Quote the link command for shipping.
3958       relink_command="(cd `pwd`; $SHELL $0 --mode=relink $libtool_args @inst_prefix_dir@)"
3959       relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
3960
3961       # Only create the output if not a dry run.
3962       if test -z "$run"; then
3963         for installed in no yes; do
3964           if test "$installed" = yes; then
3965             if test -z "$install_libdir"; then
3966               break
3967             fi
3968             output="$output_objdir/$outputname"i
3969             # Replace all uninstalled libtool libraries with the installed ones
3970             newdependency_libs=
3971             for deplib in $dependency_libs; do
3972               case $deplib in
3973               *.la)
3974                 name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
3975                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
3976                 if test -z "$libdir"; then
3977                   $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
3978                   exit 1
3979                 fi
3980                 newdependency_libs="$newdependency_libs $libdir/$name"
3981                 ;;
3982               *) newdependency_libs="$newdependency_libs $deplib" ;;
3983               esac
3984             done
3985             dependency_libs="$newdependency_libs"
3986             newdlfiles=
3987             for lib in $dlfiles; do
3988               name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
3989               eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
3990               if test -z "$libdir"; then
3991                 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
3992                 exit 1
3993               fi
3994               newdlfiles="$newdlfiles $libdir/$name"
3995             done
3996             dlfiles="$newdlfiles"
3997             newdlprefiles=
3998             for lib in $dlprefiles; do
3999               name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
4000               eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
4001               if test -z "$libdir"; then
4002                 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
4003                 exit 1
4004               fi
4005               newdlprefiles="$newdlprefiles $libdir/$name"
4006             done
4007             dlprefiles="$newdlprefiles"
4008           fi
4009           $rm $output
4010           # place dlname in correct position for cygwin
4011           tdlname=$dlname
4012           case $host,$output,$installed,$module,$dlname in
4013             *cygwin*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
4014           esac
4015           $echo > $output "\
4016 # $outputname - a libtool library file
4017 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4018 #
4019 # Please DO NOT delete this file!
4020 # It is necessary for linking the library.
4021
4022 # The name that we can dlopen(3).
4023 dlname='$tdlname'
4024
4025 # Names of this library.
4026 library_names='$library_names'
4027
4028 # The name of the static archive.
4029 old_library='$old_library'
4030
4031 # Libraries that this one depends upon.
4032 dependency_libs='$dependency_libs'
4033
4034 # Version information for $libname.
4035 current=$current
4036 age=$age
4037 revision=$revision
4038
4039 # Is this an already installed library?
4040 installed=$installed
4041
4042 # Files to dlopen/dlpreopen
4043 dlopen='$dlfiles'
4044 dlpreopen='$dlprefiles'
4045
4046 # Directory that this library needs to be installed in:
4047 libdir='$install_libdir'"
4048           if test "$installed" = no && test $need_relink = yes; then
4049             $echo >> $output "\
4050 relink_command=\"$relink_command\""
4051           fi
4052         done
4053       fi
4054
4055       # Do a symbolic link so that the libtool archive can be found in
4056       # LD_LIBRARY_PATH before the program is installed.
4057       $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
4058       $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
4059       ;;
4060     esac
4061     exit 0
4062     ;;
4063
4064   # libtool install mode
4065   install)
4066     modename="$modename: install"
4067
4068     # There may be an optional sh(1) argument at the beginning of
4069     # install_prog (especially on Windows NT).
4070     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
4071        # Allow the use of GNU shtool's install command.
4072        $echo "X$nonopt" | $Xsed | grep shtool > /dev/null; then
4073       # Aesthetically quote it.
4074       arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
4075       case $arg in
4076       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
4077         arg="\"$arg\""
4078         ;;
4079       esac
4080       install_prog="$arg "
4081       arg="$1"
4082       shift
4083     else
4084       install_prog=
4085       arg="$nonopt"
4086     fi
4087
4088     # The real first argument should be the name of the installation program.
4089     # Aesthetically quote it.
4090     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
4091     case $arg in
4092     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*)
4093       arg="\"$arg\""
4094       ;;
4095     esac
4096     install_prog="$install_prog$arg"
4097
4098     # We need to accept at least all the BSD install flags.
4099     dest=
4100     files=
4101     opts=
4102     prev=
4103     install_type=
4104     isdir=no
4105     stripme=
4106     for arg
4107     do
4108       if test -n "$dest"; then
4109         files="$files $dest"
4110         dest="$arg"
4111         continue
4112       fi
4113
4114       case $arg in
4115       -d) isdir=yes ;;
4116       -f) prev="-f" ;;
4117       -g) prev="-g" ;;
4118       -m) prev="-m" ;;
4119       -o) prev="-o" ;;
4120       -s)
4121         stripme=" -s"
4122         continue
4123         ;;
4124       -*) ;;
4125
4126       *)
4127         # If the previous option needed an argument, then skip it.
4128         if test -n "$prev"; then
4129           prev=
4130         else
4131           dest="$arg"
4132           continue
4133         fi
4134         ;;
4135       esac
4136
4137       # Aesthetically quote the argument.
4138       arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
4139       case $arg in
4140       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
4141         arg="\"$arg\""
4142         ;;
4143       esac
4144       install_prog="$install_prog $arg"
4145     done
4146
4147     if test -z "$install_prog"; then
4148       $echo "$modename: you must specify an install program" 1>&2
4149       $echo "$help" 1>&2
4150       exit 1
4151     fi
4152
4153     if test -n "$prev"; then
4154       $echo "$modename: the \`$prev' option requires an argument" 1>&2
4155       $echo "$help" 1>&2
4156       exit 1
4157     fi
4158
4159     if test -z "$files"; then
4160       if test -z "$dest"; then
4161         $echo "$modename: no file or destination specified" 1>&2
4162       else
4163         $echo "$modename: you must specify a destination" 1>&2
4164       fi
4165       $echo "$help" 1>&2
4166       exit 1
4167     fi
4168
4169     # Strip any trailing slash from the destination.
4170     dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
4171
4172     # Check to see that the destination is a directory.
4173     test -d "$dest" && isdir=yes
4174     if test "$isdir" = yes; then
4175       destdir="$dest"
4176       destname=
4177     else
4178       destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
4179       test "X$destdir" = "X$dest" && destdir=.
4180       destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
4181
4182       # Not a directory, so check to see that there is only one file specified.
4183       set dummy $files
4184       if test $# -gt 2; then
4185         $echo "$modename: \`$dest' is not a directory" 1>&2
4186         $echo "$help" 1>&2
4187         exit 1
4188       fi
4189     fi
4190     case $destdir in
4191     [\\/]* | [A-Za-z]:[\\/]*) ;;
4192     *)
4193       for file in $files; do
4194         case $file in
4195         *.lo) ;;
4196         *)
4197           $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
4198           $echo "$help" 1>&2
4199           exit 1
4200           ;;
4201         esac
4202       done
4203       ;;
4204     esac
4205
4206     # This variable tells wrapper scripts just to set variables rather
4207     # than running their programs.
4208     libtool_install_magic="$magic"
4209
4210     staticlibs=
4211     future_libdirs=
4212     current_libdirs=
4213     for file in $files; do
4214
4215       # Do each installation.
4216       case $file in
4217       *.$libext)
4218         # Do the static libraries later.
4219         staticlibs="$staticlibs $file"
4220         ;;
4221
4222       *.la)
4223         # Check to see that this really is a libtool archive.
4224         if (${SED} -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
4225         else
4226           $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
4227           $echo "$help" 1>&2
4228           exit 1
4229         fi
4230
4231         library_names=
4232         old_library=
4233         relink_command=
4234         # If there is no directory component, then add one.
4235         case $file in
4236         */* | *\\*) . $file ;;
4237         *) . ./$file ;;
4238         esac
4239
4240         # Add the libdir to current_libdirs if it is the destination.
4241         if test "X$destdir" = "X$libdir"; then
4242           case "$current_libdirs " in
4243           *" $libdir "*) ;;
4244           *) current_libdirs="$current_libdirs $libdir" ;;
4245           esac
4246         else
4247           # Note the libdir as a future libdir.
4248           case "$future_libdirs " in
4249           *" $libdir "*) ;;
4250           *) future_libdirs="$future_libdirs $libdir" ;;
4251           esac
4252         fi
4253
4254         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
4255         test "X$dir" = "X$file/" && dir=
4256         dir="$dir$objdir"
4257
4258         if test -n "$relink_command"; then
4259           # Determine the prefix the user has applied to our future dir.
4260           inst_prefix_dir=`$echo "$destdir" | sed "s%$libdir\$%%"`
4261
4262           # Don't allow the user to place us outside of our expected
4263           # location b/c this prevents finding dependent libraries that
4264           # are installed to the same prefix.
4265           if test "$inst_prefix_dir" = "$destdir"; then
4266             $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
4267             exit 1
4268           fi
4269
4270           if test -n "$inst_prefix_dir"; then
4271             # Stick the inst_prefix_dir data into the link command.
4272             relink_command=`$echo "$relink_command" | sed "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
4273           else
4274             relink_command=`$echo "$relink_command" | sed "s%@inst_prefix_dir@%%"`
4275           fi
4276
4277           $echo "$modename: warning: relinking \`$file'" 1>&2
4278           $show "$relink_command"
4279           if $run eval "$relink_command"; then :
4280           else
4281             $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
4282             exit 1
4283           fi
4284         fi
4285
4286         # See the names of the shared library.
4287         set dummy $library_names
4288         if test -n "$2"; then
4289           realname="$2"
4290           shift
4291           shift
4292
4293           srcname="$realname"
4294           test -n "$relink_command" && srcname="$realname"T
4295
4296           # Install the shared library and build the symlinks.
4297           $show "$install_prog $dir/$srcname $destdir/$realname"
4298           $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
4299           if test -n "$stripme" && test -n "$striplib"; then
4300             $show "$striplib $destdir/$realname"
4301             $run eval "$striplib $destdir/$realname" || exit $?
4302           fi
4303
4304           if test $# -gt 0; then
4305             # Delete the old symlinks, and create new ones.
4306             for linkname
4307             do
4308               if test "$linkname" != "$realname"; then
4309                 $show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
4310                 $run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
4311               fi
4312             done
4313           fi
4314
4315           # Do each command in the postinstall commands.
4316           lib="$destdir/$realname"
4317           eval cmds=\"$postinstall_cmds\"
4318           save_ifs="$IFS"; IFS='~'
4319           for cmd in $cmds; do
4320             IFS="$save_ifs"
4321             $show "$cmd"
4322             $run eval "$cmd" || exit $?
4323           done
4324           IFS="$save_ifs"
4325         fi
4326
4327         # Install the pseudo-library for information purposes.
4328         name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4329         instname="$dir/$name"i
4330         $show "$install_prog $instname $destdir/$name"
4331         $run eval "$install_prog $instname $destdir/$name" || exit $?
4332
4333         # Maybe install the static library, too.
4334         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
4335         ;;
4336
4337       *.lo)
4338         # Install (i.e. copy) a libtool object.
4339
4340         # Figure out destination file name, if it wasn't already specified.
4341         if test -n "$destname"; then
4342           destfile="$destdir/$destname"
4343         else
4344           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4345           destfile="$destdir/$destfile"
4346         fi
4347
4348         # Deduce the name of the destination old-style object file.
4349         case $destfile in
4350         *.lo)
4351           staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
4352           ;;
4353         *.$objext)
4354           staticdest="$destfile"
4355           destfile=
4356           ;;
4357         *)
4358           $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
4359           $echo "$help" 1>&2
4360           exit 1
4361           ;;
4362         esac
4363
4364         # Install the libtool object if requested.
4365         if test -n "$destfile"; then
4366           $show "$install_prog $file $destfile"
4367           $run eval "$install_prog $file $destfile" || exit $?
4368         fi
4369
4370         # Install the old object if enabled.
4371         if test "$build_old_libs" = yes; then
4372           # Deduce the name of the old-style object file.
4373           staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
4374
4375           $show "$install_prog $staticobj $staticdest"
4376           $run eval "$install_prog \$staticobj \$staticdest" || exit $?
4377         fi
4378         exit 0
4379         ;;
4380
4381       *)
4382         # Figure out destination file name, if it wasn't already specified.
4383         if test -n "$destname"; then
4384           destfile="$destdir/$destname"
4385         else
4386           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4387           destfile="$destdir/$destfile"
4388         fi
4389
4390         # Do a test to see if this is really a libtool program.
4391         case $host in
4392         *cygwin*|*mingw*)
4393             wrapper=`echo $file | ${SED} -e 's,.exe$,,'`
4394             ;;
4395         *)
4396             wrapper=$file
4397             ;;
4398         esac
4399         if (${SED} -e '4q' $wrapper | egrep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
4400           notinst_deplibs=
4401           relink_command=
4402
4403           # If there is no directory component, then add one.
4404           case $file in
4405           */* | *\\*) . $wrapper ;;
4406           *) . ./$wrapper ;;
4407           esac
4408
4409           # Check the variables that should have been set.
4410           if test -z "$notinst_deplibs"; then
4411             $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
4412             exit 1
4413           fi
4414
4415           finalize=yes
4416           for lib in $notinst_deplibs; do
4417             # Check to see that each library is installed.
4418             libdir=
4419             if test -f "$lib"; then
4420               # If there is no directory component, then add one.
4421               case $lib in
4422               */* | *\\*) . $lib ;;
4423               *) . ./$lib ;;
4424               esac
4425             fi
4426             libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
4427             if test -n "$libdir" && test ! -f "$libfile"; then
4428               $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
4429               finalize=no
4430             fi
4431           done
4432
4433           relink_command=
4434           # If there is no directory component, then add one.
4435           case $file in
4436           */* | *\\*) . $wrapper ;;
4437           *) . ./$wrapper ;;
4438           esac
4439
4440           outputname=
4441           if test "$fast_install" = no && test -n "$relink_command"; then
4442             if test "$finalize" = yes && test -z "$run"; then
4443               tmpdir="/tmp"
4444               test -n "$TMPDIR" && tmpdir="$TMPDIR"
4445               tmpdir="$tmpdir/libtool-$$"
4446               if $mkdir -p "$tmpdir" && chmod 700 "$tmpdir"; then :
4447               else
4448                 $echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
4449                 continue
4450               fi
4451               file=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4452               outputname="$tmpdir/$file"
4453               # Replace the output file specification.
4454               relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
4455
4456               $show "$relink_command"
4457               if $run eval "$relink_command"; then :
4458               else
4459                 $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
4460                 ${rm}r "$tmpdir"
4461                 continue
4462               fi
4463               file="$outputname"
4464             else
4465               $echo "$modename: warning: cannot relink \`$file'" 1>&2
4466             fi
4467           else
4468             # Install the binary that we compiled earlier.
4469             file=`$echo "X$file" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
4470           fi
4471         fi
4472
4473         # remove .exe since cygwin /usr/bin/install will append another
4474         # one anyways
4475         case $install_prog,$host in
4476         /usr/bin/install*,*cygwin*)
4477           case $file:$destfile in
4478           *.exe:*.exe)
4479             # this is ok
4480             ;;
4481           *.exe:*)
4482             destfile=$destfile.exe
4483             ;;
4484           *:*.exe)
4485             destfile=`echo $destfile | ${SED} -e 's,.exe$,,'`
4486             ;;
4487           esac
4488           ;;
4489         esac
4490         $show "$install_prog$stripme $file $destfile"
4491         $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
4492         test -n "$outputname" && ${rm}r "$tmpdir"
4493         ;;
4494       esac
4495     done
4496
4497     for file in $staticlibs; do
4498       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4499
4500       # Set up the ranlib parameters.
4501       oldlib="$destdir/$name"
4502
4503       $show "$install_prog $file $oldlib"
4504       $run eval "$install_prog \$file \$oldlib" || exit $?
4505
4506       if test -n "$stripme" && test -n "$striplib"; then
4507         $show "$old_striplib $oldlib"
4508         $run eval "$old_striplib $oldlib" || exit $?
4509       fi
4510
4511       # Do each command in the postinstall commands.
4512       eval cmds=\"$old_postinstall_cmds\"
4513       save_ifs="$IFS"; IFS='~'
4514       for cmd in $cmds; do
4515         IFS="$save_ifs"
4516         $show "$cmd"
4517         $run eval "$cmd" || exit $?
4518       done
4519       IFS="$save_ifs"
4520     done
4521
4522     if test -n "$future_libdirs"; then
4523       $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
4524     fi
4525
4526     if test -n "$current_libdirs"; then
4527       # Maybe just do a dry run.
4528       test -n "$run" && current_libdirs=" -n$current_libdirs"
4529       exec_cmd='$SHELL $0 --finish$current_libdirs'
4530     else
4531       exit 0
4532     fi
4533     ;;
4534
4535   # libtool finish mode
4536   finish)
4537     modename="$modename: finish"
4538     libdirs="$nonopt"
4539     admincmds=
4540
4541     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
4542       for dir
4543       do
4544         libdirs="$libdirs $dir"
4545       done
4546
4547       for libdir in $libdirs; do
4548         if test -n "$finish_cmds"; then
4549           # Do each command in the finish commands.
4550           eval cmds=\"$finish_cmds\"
4551           save_ifs="$IFS"; IFS='~'
4552           for cmd in $cmds; do
4553             IFS="$save_ifs"
4554             $show "$cmd"
4555             $run eval "$cmd" || admincmds="$admincmds
4556        $cmd"
4557           done
4558           IFS="$save_ifs"
4559         fi
4560         if test -n "$finish_eval"; then
4561           # Do the single finish_eval.
4562           eval cmds=\"$finish_eval\"
4563           $run eval "$cmds" || admincmds="$admincmds
4564        $cmds"
4565         fi
4566       done
4567     fi
4568
4569     # Exit here if they wanted silent mode.
4570     test "$show" = ":" && exit 0
4571
4572     echo "----------------------------------------------------------------------"
4573     echo "Libraries have been installed in:"
4574     for libdir in $libdirs; do
4575       echo "   $libdir"
4576     done
4577     echo
4578     echo "If you ever happen to want to link against installed libraries"
4579     echo "in a given directory, LIBDIR, you must either use libtool, and"
4580     echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
4581     echo "flag during linking and do at least one of the following:"
4582     if test -n "$shlibpath_var"; then
4583       echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
4584       echo "     during execution"
4585     fi
4586     if test -n "$runpath_var"; then
4587       echo "   - add LIBDIR to the \`$runpath_var' environment variable"
4588       echo "     during linking"
4589     fi
4590     if test -n "$hardcode_libdir_flag_spec"; then
4591       libdir=LIBDIR
4592       eval flag=\"$hardcode_libdir_flag_spec\"
4593
4594       echo "   - use the \`$flag' linker flag"
4595     fi
4596     if test -n "$admincmds"; then
4597       echo "   - have your system administrator run these commands:$admincmds"
4598     fi
4599     if test -f /etc/ld.so.conf; then
4600       echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
4601     fi
4602     echo
4603     echo "See any operating system documentation about shared libraries for"
4604     echo "more information, such as the ld(1) and ld.so(8) manual pages."
4605     echo "----------------------------------------------------------------------"
4606     exit 0
4607     ;;
4608
4609   # libtool execute mode
4610   execute)
4611     modename="$modename: execute"
4612
4613     # The first argument is the command name.
4614     cmd="$nonopt"
4615     if test -z "$cmd"; then
4616       $echo "$modename: you must specify a COMMAND" 1>&2
4617       $echo "$help"
4618       exit 1
4619     fi
4620
4621     # Handle -dlopen flags immediately.
4622     for file in $execute_dlfiles; do
4623       if test ! -f "$file"; then
4624         $echo "$modename: \`$file' is not a file" 1>&2
4625         $echo "$help" 1>&2
4626         exit 1
4627       fi
4628
4629       dir=
4630       case $file in
4631       *.la)
4632         # Check to see that this really is a libtool archive.
4633         if (${SED} -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
4634         else
4635           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
4636           $echo "$help" 1>&2
4637           exit 1
4638         fi
4639
4640         # Read the libtool library.
4641         dlname=
4642         library_names=
4643
4644         # If there is no directory component, then add one.
4645         case $file in
4646         */* | *\\*) . $file ;;
4647         *) . ./$file ;;
4648         esac
4649
4650         # Skip this library if it cannot be dlopened.
4651         if test -z "$dlname"; then
4652           # Warn if it was a shared library.
4653           test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
4654           continue
4655         fi
4656
4657         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
4658         test "X$dir" = "X$file" && dir=.
4659
4660         if test -f "$dir/$objdir/$dlname"; then
4661           dir="$dir/$objdir"
4662         else
4663           $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
4664           exit 1
4665         fi
4666         ;;
4667
4668       *.lo)
4669         # Just add the directory containing the .lo file.
4670         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
4671         test "X$dir" = "X$file" && dir=.
4672         ;;
4673
4674       *)
4675         $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
4676         continue
4677         ;;
4678       esac
4679
4680       # Get the absolute pathname.
4681       absdir=`cd "$dir" && pwd`
4682       test -n "$absdir" && dir="$absdir"
4683
4684       # Now add the directory to shlibpath_var.
4685       if eval "test -z \"\$$shlibpath_var\""; then
4686         eval "$shlibpath_var=\"\$dir\""
4687       else
4688         eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
4689       fi
4690     done
4691
4692     # This variable tells wrapper scripts just to set shlibpath_var
4693     # rather than running their programs.
4694     libtool_execute_magic="$magic"
4695
4696     # Check if any of the arguments is a wrapper script.
4697     args=
4698     for file
4699     do
4700       case $file in
4701       -*) ;;
4702       *)
4703         # Do a test to see if this is really a libtool program.
4704         if (${SED} -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
4705           # If there is no directory component, then add one.
4706           case $file in
4707           */* | *\\*) . $file ;;
4708           *) . ./$file ;;
4709           esac
4710
4711           # Transform arg to wrapped name.
4712           file="$progdir/$program"
4713         fi
4714         ;;
4715       esac
4716       # Quote arguments (to preserve shell metacharacters).
4717       file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
4718       args="$args \"$file\""
4719     done
4720
4721     if test -z "$run"; then
4722       if test -n "$shlibpath_var"; then
4723         # Export the shlibpath_var.
4724         eval "export $shlibpath_var"
4725       fi
4726
4727       # Restore saved enviroment variables
4728       if test "${save_LC_ALL+set}" = set; then
4729         LC_ALL="$save_LC_ALL"; export LC_ALL
4730       fi
4731       if test "${save_LANG+set}" = set; then
4732         LANG="$save_LANG"; export LANG
4733       fi
4734
4735       # Now prepare to actually exec the command.
4736       exec_cmd="\$cmd$args"
4737     else
4738       # Display what would be done.
4739       if test -n "$shlibpath_var"; then
4740         eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
4741         $echo "export $shlibpath_var"
4742       fi
4743       $echo "$cmd$args"
4744       exit 0
4745     fi
4746     ;;
4747
4748   # libtool clean and uninstall mode
4749   clean | uninstall)
4750     modename="$modename: $mode"
4751     rm="$nonopt"
4752     files=
4753     rmforce=
4754     exit_status=0
4755
4756     # This variable tells wrapper scripts just to set variables rather
4757     # than running their programs.
4758     libtool_install_magic="$magic"
4759
4760     for arg
4761     do
4762       case $arg in
4763       -f) rm="$rm $arg"; rmforce=yes ;;
4764       -*) rm="$rm $arg" ;;
4765       *) files="$files $arg" ;;
4766       esac
4767     done
4768
4769     if test -z "$rm"; then
4770       $echo "$modename: you must specify an RM program" 1>&2
4771       $echo "$help" 1>&2
4772       exit 1
4773     fi
4774
4775     rmdirs=
4776
4777     for file in $files; do
4778       dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
4779       if test "X$dir" = "X$file"; then
4780         dir=.
4781         objdir="$objdir"
4782       else
4783         objdir="$dir/$objdir"
4784       fi
4785       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4786       test $mode = uninstall && objdir="$dir"
4787
4788       # Remember objdir for removal later, being careful to avoid duplicates
4789       if test $mode = clean; then
4790         case " $rmdirs " in
4791           *" $objdir "*) ;;
4792           *) rmdirs="$rmdirs $objdir" ;;
4793         esac
4794       fi
4795
4796       # Don't error if the file doesn't exist and rm -f was used.
4797       if (test -L "$file") >/dev/null 2>&1 \
4798         || (test -h "$file") >/dev/null 2>&1 \
4799         || test -f "$file"; then
4800         :
4801       elif test -d "$file"; then
4802         exit_status=1
4803         continue
4804       elif test "$rmforce" = yes; then
4805         continue
4806       fi
4807
4808       rmfiles="$file"
4809
4810       case $name in
4811       *.la)
4812         # Possibly a libtool archive, so verify it.
4813         if (${SED} -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
4814           . $dir/$name
4815
4816           # Delete the libtool libraries and symlinks.
4817           for n in $library_names; do
4818             rmfiles="$rmfiles $objdir/$n"
4819           done
4820           test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
4821           test $mode = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
4822
4823           if test $mode = uninstall; then
4824             if test -n "$library_names"; then
4825               # Do each command in the postuninstall commands.
4826               eval cmds=\"$postuninstall_cmds\"
4827               save_ifs="$IFS"; IFS='~'
4828               for cmd in $cmds; do
4829                 IFS="$save_ifs"
4830                 $show "$cmd"
4831                 $run eval "$cmd"
4832                 if test $? != 0 && test "$rmforce" != yes; then
4833                   exit_status=1
4834                 fi
4835               done
4836               IFS="$save_ifs"
4837             fi
4838
4839             if test -n "$old_library"; then
4840               # Do each command in the old_postuninstall commands.
4841               eval cmds=\"$old_postuninstall_cmds\"
4842               save_ifs="$IFS"; IFS='~'
4843               for cmd in $cmds; do
4844                 IFS="$save_ifs"
4845                 $show "$cmd"
4846                 $run eval "$cmd"
4847                 if test $? != 0 && test "$rmforce" != yes; then
4848                   exit_status=1
4849                 fi
4850               done
4851               IFS="$save_ifs"
4852             fi
4853             # FIXME: should reinstall the best remaining shared library.
4854           fi
4855         fi
4856         ;;
4857
4858       *.lo)
4859         if test "$build_old_libs" = yes; then
4860           oldobj=`$echo "X$name" | $Xsed -e "$lo2o"`
4861           rmfiles="$rmfiles $dir/$oldobj"
4862         fi
4863         ;;
4864
4865       *)
4866         # Do a test to see if this is a libtool program.
4867         if test $mode = clean &&
4868            (${SED} -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
4869           relink_command=
4870           . $dir/$file
4871
4872           rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
4873           if test "$fast_install" = yes && test -n "$relink_command"; then
4874             rmfiles="$rmfiles $objdir/lt-$name"
4875           fi
4876         fi
4877         ;;
4878       esac
4879       $show "$rm $rmfiles"
4880       $run $rm $rmfiles || exit_status=1
4881     done
4882
4883     # Try to remove the ${objdir}s in the directories where we deleted files
4884     for dir in $rmdirs; do
4885       if test -d "$dir"; then
4886         $show "rmdir $dir"
4887         $run rmdir $dir >/dev/null 2>&1
4888       fi
4889     done
4890
4891     exit $exit_status
4892     ;;
4893
4894   "")
4895     $echo "$modename: you must specify a MODE" 1>&2
4896     $echo "$generic_help" 1>&2
4897     exit 1
4898     ;;
4899   esac
4900
4901   if test -z "$exec_cmd"; then
4902     $echo "$modename: invalid operation mode \`$mode'" 1>&2
4903     $echo "$generic_help" 1>&2
4904     exit 1
4905   fi
4906 fi # test -z "$show_help"
4907
4908 if test -n "$exec_cmd"; then
4909   eval exec $exec_cmd
4910   exit 1
4911 fi
4912
4913 # We need to display help for each of the modes.
4914 case $mode in
4915 "") $echo \
4916 "Usage: $modename [OPTION]... [MODE-ARG]...
4917
4918 Provide generalized library-building support services.
4919
4920     --config          show all configuration variables
4921     --debug           enable verbose shell tracing
4922 -n, --dry-run         display commands without modifying any files
4923     --features        display basic configuration information and exit
4924     --finish          same as \`--mode=finish'
4925     --help            display this help message and exit
4926     --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
4927     --quiet           same as \`--silent'
4928     --silent          don't print informational messages
4929     --version         print version information
4930
4931 MODE must be one of the following:
4932
4933       clean           remove files from the build directory
4934       compile         compile a source file into a libtool object
4935       execute         automatically set library path, then run a program
4936       finish          complete the installation of libtool libraries
4937       install         install libraries or executables
4938       link            create a library or an executable
4939       uninstall       remove libraries from an installed directory
4940
4941 MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
4942 a more detailed description of MODE."
4943   exit 0
4944   ;;
4945
4946 clean)
4947   $echo \
4948 "Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
4949
4950 Remove files from the build directory.
4951
4952 RM is the name of the program to use to delete files associated with each FILE
4953 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
4954 to RM.
4955
4956 If FILE is a libtool library, object or program, all the files associated
4957 with it are deleted. Otherwise, only FILE itself is deleted using RM."
4958   ;;
4959
4960 compile)
4961   $echo \
4962 "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
4963
4964 Compile a source file into a libtool library object.
4965
4966 This mode accepts the following additional options:
4967
4968   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
4969   -prefer-pic       try to building PIC objects only
4970   -prefer-non-pic   try to building non-PIC objects only
4971   -static           always build a \`.o' file suitable for static linking
4972
4973 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
4974 from the given SOURCEFILE.
4975
4976 The output file name is determined by removing the directory component from
4977 SOURCEFILE, then substituting the C source code suffix \`.c' with the
4978 library object suffix, \`.lo'."
4979   ;;
4980
4981 execute)
4982   $echo \
4983 "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
4984
4985 Automatically set library path, then run a program.
4986
4987 This mode accepts the following additional options:
4988
4989   -dlopen FILE      add the directory containing FILE to the library path
4990
4991 This mode sets the library path environment variable according to \`-dlopen'
4992 flags.
4993
4994 If any of the ARGS are libtool executable wrappers, then they are translated
4995 into their corresponding uninstalled binary, and any of their required library
4996 directories are added to the library path.
4997
4998 Then, COMMAND is executed, with ARGS as arguments."
4999   ;;
5000
5001 finish)
5002   $echo \
5003 "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
5004
5005 Complete the installation of libtool libraries.
5006
5007 Each LIBDIR is a directory that contains libtool libraries.
5008
5009 The commands that this mode executes may require superuser privileges.  Use
5010 the \`--dry-run' option if you just want to see what would be executed."
5011   ;;
5012
5013 install)
5014   $echo \
5015 "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
5016
5017 Install executables or libraries.
5018
5019 INSTALL-COMMAND is the installation command.  The first component should be
5020 either the \`install' or \`cp' program.
5021
5022 The rest of the components are interpreted as arguments to that command (only
5023 BSD-compatible install options are recognized)."
5024   ;;
5025
5026 link)
5027   $echo \
5028 "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
5029
5030 Link object files or libraries together to form another library, or to
5031 create an executable program.
5032
5033 LINK-COMMAND is a command using the C compiler that you would use to create
5034 a program from several object files.
5035
5036 The following components of LINK-COMMAND are treated specially:
5037
5038   -all-static       do not do any dynamic linking at all
5039   -avoid-version    do not add a version suffix if possible
5040   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
5041   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
5042   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
5043   -export-symbols SYMFILE
5044                     try to export only the symbols listed in SYMFILE
5045   -export-symbols-regex REGEX
5046                     try to export only the symbols matching REGEX
5047   -LLIBDIR          search LIBDIR for required installed libraries
5048   -lNAME            OUTPUT-FILE requires the installed library libNAME
5049   -module           build a library that can dlopened
5050   -no-fast-install  disable the fast-install mode
5051   -no-install       link a not-installable executable
5052   -no-undefined     declare that a library does not refer to external symbols
5053   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
5054   -release RELEASE  specify package release information
5055   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
5056   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
5057   -static           do not do any dynamic linking of libtool libraries
5058   -version-info CURRENT[:REVISION[:AGE]]
5059                     specify library version info [each variable defaults to 0]
5060
5061 All other options (arguments beginning with \`-') are ignored.
5062
5063 Every other argument is treated as a filename.  Files ending in \`.la' are
5064 treated as uninstalled libtool libraries, other files are standard or library
5065 object files.
5066
5067 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
5068 only library objects (\`.lo' files) may be specified, and \`-rpath' is
5069 required, except when creating a convenience library.
5070
5071 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
5072 using \`ar' and \`ranlib', or on Windows using \`lib'.
5073
5074 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
5075 is created, otherwise an executable program is created."
5076   ;;
5077
5078 uninstall)
5079   $echo \
5080 "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
5081
5082 Remove libraries from an installation directory.
5083
5084 RM is the name of the program to use to delete files associated with each FILE
5085 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
5086 to RM.
5087
5088 If FILE is a libtool library, all the files associated with it are deleted.
5089 Otherwise, only FILE itself is deleted using RM."
5090   ;;
5091
5092 *)
5093   $echo "$modename: invalid operation mode \`$mode'" 1>&2
5094   $echo "$help" 1>&2
5095   exit 1
5096   ;;
5097 esac
5098
5099 echo
5100 $echo "Try \`$modename --help' for more information about other modes."
5101
5102 exit 0
5103
5104 # Local Variables:
5105 # mode:shell-script
5106 # sh-indentation:2
5107 # End: