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