ltmain.sh

   1 # ltmain.sh - Provide generalized library-building support services.
   2 # NOTE: Changing this file will not affect anything until you rerun ltconfig.
   3 #
   4 # Copyright (C) 1996-1998 Free Software Foundation, Inc.
   5 # Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
   6 #
   7 # This program is free software; you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 2 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful, but
  13 # WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 # General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with this program; if not, write to the Free Software
  19 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20 #
  21 # As a special exception to the GNU General Public License, if you
  22 # distribute this file as part of a program that contains a
  23 # configuration script generated by Autoconf, you may include it under
  24 # the same distribution terms that you use for the rest of that program.
  25
  26 # Check that we have a working $echo.
  27 if test "X$1" = X--no-reexec; then
  28   # Discard the --no-reexec flag, and continue.
  29   shift
  30 elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
  31   # Yippee, $echo works!
  32   :
  33 else
  34   # Restart under the correct shell, and then maybe $echo will work.
  35   exec $SHELL "$0" --no-reexec ${1+"$@"}
  36 fi
  37
  38 # The name of this program.
  39 progname=`$echo "$0" | sed 's%^.*/%%'`
  40 modename="$progname"
  41
  42 # Constants.
  43 PROGRAM=ltmain.sh
  44 PACKAGE=libtool
  45 VERSION=1.2b
  46
  47 default_mode=
  48 help="Try \`$progname --help' for more information."
  49 magic="%%%MAGIC variable%%%"
  50 mkdir="mkdir"
  51 mv="mv -f"
  52 rm="rm -f"
  53
  54 # Sed substitution that helps us do robust quoting.  It backslashifies
  55 # metacharacters that are still active within double-quoted strings.
  56 Xsed='sed -e s/^X//'
  57 sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
  58
  59 # NLS nuisances.
  60 # Only set LANG and LC_ALL to C if already set.
  61 # These must not be set unconditionally because not all systems understand
  62 # e.g. LANG=C (notably SCO).
  63 # We save the old values to restore during execute mode.
  64 if test "${LC_ALL+set}" = set; then
  65   save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
  66 fi
  67 if test "${LANG+set}" = set; then
  68   save_LANG="$LANG"; LANG=C; export LANG
  69 fi
  70
  71 if test "$LTCONFIG_VERSION" != "$VERSION"; then
  72   echo "$modename: ltconfig version \`$LTCONFIG_VERSION' does not match $PROGRAM version \`$VERSION'" 1>&2
  73   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  74   exit 1
  75 fi
  76
  77 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
  78   echo "$modename: not configured to build any kind of library" 1>&2
  79   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  80   exit 1
  81 fi
  82
  83 # Global variables.
  84 mode=$default_mode
  85 nonopt=
  86 prev=
  87 prevopt=
  88 run=
  89 show="$echo"
  90 show_help=
  91 execute_dlfiles=
  92 lo2o="s/\\.lo\$/.${objext}/"
  93 los2o="s/\\.lo /.${objext} /g"
  94
  95 # Parse our command line options once, thoroughly.
  96 while test $# -gt 0
  97 do
  98   arg="$1"
  99   shift
 100
 101   case "$arg" in
 102   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
 103   *) optarg= ;;
 104   esac
 105
 106   # If the previous option needs an argument, assign it.
 107   if test -n "$prev"; then
 108     case "$prev" in
 109     execute_dlfiles)
 110       eval "$prev=\"\$$prev \$arg\""
 111       ;;
 112     *)
 113       eval "$prev=\$arg"
 114       ;;
 115     esac
 116
 117     prev=
 118     prevopt=
 119     continue
 120   fi
 121
 122   # Have we seen a non-optional argument yet?
 123   case "$arg" in
 124   --help)
 125     show_help=yes
 126     ;;
 127
 128   --version)
 129     echo "$PROGRAM (GNU $PACKAGE) $VERSION"
 130     exit 0
 131     ;;
 132
 133   --config)
 134     sed -e '1,/^### BEGIN LIBTOOL CONFIG/d' -e '/^### END LIBTOOL CONFIG/,$d' $0
 135     exit 0
 136     ;;
 137
 138   --debug)
 139     echo "$progname: enabling shell trace mode"
 140     set -x
 141     ;;
 142
 143   --dry-run | -n)
 144     run=:
 145     ;;
 146
 147   --features)
 148     echo "host: $host"
 149     if test "$build_libtool_libs" = yes; then
 150       echo "enable shared libraries"
 151     else
 152       echo "disable shared libraries"
 153     fi
 154     if test "$build_old_libs" = yes; then
 155       echo "enable static libraries"
 156     else
 157       echo "disable static libraries"
 158     fi
 159     exit 0
 160     ;;
 161
 162   --finish) mode="finish" ;;
 163
 164   --mode) prevopt="--mode" prev=mode ;;
 165   --mode=*) mode="$optarg" ;;
 166
 167   --quiet | --silent)
 168     show=:
 169     ;;
 170
 171   -dlopen)
 172     prevopt="-dlopen"
 173     prev=execute_dlfiles
 174     ;;
 175
 176   -*)
 177     $echo "$modename: unrecognized option \`$arg'" 1>&2
 178     $echo "$help" 1>&2
 179     exit 1
 180     ;;
 181
 182   *)
 183     nonopt="$arg"
 184     break
 185     ;;
 186   esac
 187 done
 188
 189 if test -n "$prevopt"; then
 190   $echo "$modename: option \`$prevopt' requires an argument" 1>&2
 191   $echo "$help" 1>&2
 192   exit 1
 193 fi
 194
 195 if test -z "$show_help"; then
 196
 197   # Infer the operation mode.
 198   if test -z "$mode"; then
 199     case "$nonopt" in
 200     *cc | *++ | gcc* | *-gcc*)
 201       mode=link
 202       for arg
 203       do
 204         case "$arg" in
 205         -c)
 206            mode=compile
 207            break
 208            ;;
 209         esac
 210       done
 211       ;;
 212     *db | *dbx | *strace | *truss)
 213       mode=execute
 214       ;;
 215     *install*|cp|mv)
 216       mode=install
 217       ;;
 218     *rm)
 219       mode=uninstall
 220       ;;
 221     *)
 222       # If we have no mode, but dlfiles were specified, then do execute mode.
 223       test -n "$execute_dlfiles" && mode=execute
 224
 225       # Just use the default operation mode.
 226       if test -z "$mode"; then
 227         if test -n "$nonopt"; then
 228           $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
 229         else
 230           $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
 231         fi
 232       fi
 233       ;;
 234     esac
 235   fi
 236
 237   # Only execute mode is allowed to have -dlopen flags.
 238   if test -n "$execute_dlfiles" && test "$mode" != execute; then
 239     $echo "$modename: unrecognized option \`-dlopen'" 1>&2
 240     $echo "$help" 1>&2
 241     exit 1
 242   fi
 243
 244   # Change the help message to a mode-specific one.
 245   generic_help="$help"
 246   help="Try \`$modename --help --mode=$mode' for more information."
 247
 248   # These modes are in order of execution frequency so that they run quickly.
 249   case "$mode" in
 250   # libtool compile mode
 251   compile)
 252     modename="$modename: compile"
 253     # Get the compilation command and the source file.
 254     base_compile=
 255     lastarg=
 256     srcfile="$nonopt"
 257     suppress_output=
 258
 259     for arg
 260     do
 261       # Accept any command-line options.
 262       case "$arg" in
 263       -o)
 264         $echo "$modename: you cannot specify the output filename with \`-o'" 1>&2
 265         $echo "$help" 1>&2
 266         exit 1
 267         ;;
 268
 269       -static)
 270         build_old_libs=yes
 271         continue
 272         ;;
 273       esac
 274
 275       # Accept the current argument as the source file.
 276       lastarg="$srcfile"
 277       srcfile="$arg"
 278
 279       # Aesthetically quote the previous argument.
 280
 281       # Backslashify any backslashes, double quotes, and dollar signs.
 282       # These are the only characters that are still specially
 283       # interpreted inside of double-quoted scrings.
 284       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
 285
 286       # Double-quote args containing other shell metacharacters.
 287       # Many Bourne shells cannot handle close brackets correctly in scan
 288       # sets, so we specify it separately.
 289       case "$lastarg" in
 290       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
 291         lastarg="\"$lastarg\""
 292         ;;
 293       esac
 294
 295       # Add the previous argument to base_compile.
 296       if test -z "$base_compile"; then
 297         base_compile="$lastarg"
 298       else
 299         base_compile="$base_compile $lastarg"
 300       fi
 301     done
 302
 303     # Get the name of the library object.
 304     libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
 305
 306     # Recognize several different file suffixes.
 307     xform='[cCFSfms]'
 308     case "$libobj" in
 309     *.ada) xform=ada ;;
 310     *.adb) xform=adb ;;
 311     *.ads) xform=ads ;;
 312     *.asm) xform=asm ;;
 313     *.c++) xform=c++ ;;
 314     *.cc) xform=cc ;;
 315     *.cpp) xform=cpp ;;
 316     *.cxx) xform=cxx ;;
 317     *.f90) xform=f90 ;;
 318     *.for) xform=for ;;
 319     esac
 320
 321     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
 322
 323     case "$libobj" in
 324     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
 325     *)
 326       $echo "$modename: cannot determine name of library object from \`$srcfile'" 1>&2
 327       exit 1
 328       ;;
 329     esac
 330
 331     if test -z "$base_compile"; then
 332       $echo "$modename: you must specify a compilation command" 1>&2
 333       $echo "$help" 1>&2
 334       exit 1
 335     fi
 336
 337     # Delete any leftover library objects.
 338     if test "$build_old_libs" = yes; then
 339       $run $rm $obj $libobj
 340       trap "$run $rm $obj $libobj; exit 1" 1 2 15
 341     else
 342       $run $rm $libobj
 343       trap "$run $rm $libobj; exit 1" 1 2 15
 344     fi
 345
 346     if test -n "$fix_srcfile_path"; then
 347       eval srcfile=\"$fix_srcfile_path\"
 348     fi
 349
 350     # Only build a PIC object if we are building libtool libraries.
 351     if test "$build_libtool_libs" = yes; then
 352       # Without this assignment, base_compile gets emptied.
 353       fbsd_hideous_sh_bug=$base_compile
 354
 355       # All platforms use -DPIC, to notify preprocessed assembler code.
 356       $show "$base_compile$pic_flag -DPIC $srcfile"
 357       if $run eval "$base_compile\$pic_flag -DPIC \$srcfile"; then :
 358       else
 359         test -n "$obj" && $run $rm $obj
 360         exit 1
 361       fi
 362
 363       # If we have no pic_flag, then copy the object into place and finish.
 364       if test -z "$pic_flag"; then
 365         $show "$LN_S $obj $libobj"
 366         $run $LN_S $obj $libobj
 367         exit $?
 368       fi
 369
 370       # Just move the object, then go on to compile the next one
 371       $show "$mv $obj $libobj"
 372       $run $mv $obj $libobj || exit $?
 373
 374       # Allow error messages only from the first compilation.
 375       suppress_output=' >/dev/null 2>&1'
 376     fi
 377
 378     # Only build a position-dependent object if we build old libraries.
 379     if test "$build_old_libs" = yes; then
 380       # Suppress compiler output if we already did a PIC compilation.
 381       $show "$base_compile $srcfile$suppress_output"
 382       if $run eval "$base_compile \$srcfile$suppress_output"; then :
 383       else
 384         $run $rm $obj $libobj
 385         exit 1
 386       fi
 387     fi
 388
 389     # Create an invalid libtool object if no PIC, so that we do not
 390     # accidentally link it into a program.
 391     if test "$build_libtool_libs" != yes; then
 392       $show "echo timestamp > $libobj"
 393       $run eval "echo timestamp > \$libobj" || exit $?
 394     fi
 395
 396     exit 0
 397     ;;
 398
 399   # libtool link mode
 400   link)
 401     modename="$modename: link"
 402     CC="$nonopt"
 403     allow_undefined=yes
 404     compile_command="$CC"
 405     finalize_command="$CC"
 406
 407     compile_shlibpath=
 408     finalize_shlibpath=
 409     convenience=
 410     old_convenience=
 411     deplibs=
 412     dlfiles=
 413     dlprefiles=
 414     export_dynamic=no
 415     generated=
 416     hardcode_libdirs=
 417     libobjs=
 418     link_against_libtool_libs=
 419     ltlibs=
 420     objs=
 421     prev=
 422     prevarg=
 423     release=
 424     rpath=
 425     perm_rpath=
 426     temp_rpath=
 427     vinfo=
 428
 429     # We need to know -static, to get the right output filenames.
 430     for arg
 431     do
 432       case "$arg" in
 433       -all-static | -static)
 434         if test "X$arg" = "X-all-static" && test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
 435             $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
 436         fi
 437         build_libtool_libs=no
 438         build_old_libs=yes
 439         break
 440         ;;
 441       esac
 442     done
 443
 444     # See if our shared archives depend on static archives.
 445     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
 446
 447     # Go through the arguments, transforming them on the way.
 448     while test $# -gt 0; do
 449       arg="$1"
 450       shift
 451
 452       # If the previous option needs an argument, assign it.
 453       if test -n "$prev"; then
 454         case "$prev" in
 455         output)
 456           compile_command="$compile_command @OUTPUT@"
 457           finalize_command="$finalize_command @OUTPUT@"
 458           ;;
 459         esac
 460
 461         case "$prev" in
 462         dlfiles|dlprefiles)
 463           case "$arg" in
 464           *.la | *.lo) ;;  # We handle these cases below.
 465           *)
 466             dlprefiles="$dlprefiles $arg"
 467             test "$prev" = dlfiles && dlfiles="$dlfiles $arg"
 468             prev=
 469             ;;
 470           esac
 471           ;;
 472         release)
 473           release="-$arg"
 474           prev=
 475           continue
 476           ;;
 477         rpath)
 478           rpath="$rpath $arg"
 479           prev=
 480           continue
 481           ;;
 482         *)
 483           eval "$prev=\"\$arg\""
 484           prev=
 485           continue
 486           ;;
 487         esac
 488       fi
 489
 490       prevarg="$arg"
 491
 492       case "$arg" in
 493       -all-static)
 494         if test -n "$link_static_flag"; then
 495           compile_command="$compile_command $link_static_flag"
 496           finalize_command="$finalize_command $link_static_flag"
 497         fi
 498         continue
 499         ;;
 500
 501       -allow-undefined)
 502         # FIXME: remove this flag sometime in the future.
 503         $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
 504         continue
 505         ;;
 506
 507       -dlopen)
 508         prev=dlfiles
 509         continue
 510         ;;
 511
 512       -dlpreopen)
 513         prev=dlprefiles
 514         continue
 515         ;;
 516
 517       -export-dynamic)
 518         if test "$export_dynamic" != yes; then
 519           export_dynamic=yes
 520           if test -n "$export_dynamic_flag_spec"; then
 521             eval arg=\"$export_dynamic_flag_spec\"
 522           else
 523             arg=
 524           fi
 525
 526           # Add the symbol object into the linking commands.
 527           compile_command="$compile_command @SYMFILE@"
 528           finalize_command="$finalize_command @SYMFILE@"
 529         fi
 530         ;;
 531
 532       -L*)
 533         dir=`$echo "X$arg" | $Xsed -e 's%^-L\(.*\)$%\1%'`
 534         case "$dir" in
 535         /* | [A-Za-z]:[/\\]*)
 536           # Add the corresponding hardcode_libdir_flag, if it is not identical.
 537           ;;
 538         *)
 539           $echo "$modename: \`-L$dir' cannot specify a relative directory" 1>&2
 540           exit 1
 541           ;;
 542         esac
 543         deplibs="$deplibs $arg"
 544         ;;
 545
 546       -l*) deplibs="$deplibs $arg" ;;
 547
 548       -no-undefined)
 549         allow_undefined=no
 550         continue
 551         ;;
 552
 553       -o) prev=output ;;
 554
 555       -release)
 556         prev=release
 557         continue
 558         ;;
 559
 560       -rpath)
 561         prev=rpath
 562         continue
 563         ;;
 564
 565       -static)
 566         # If we have no pic_flag, then this is the same as -all-static.
 567         if test -z "$pic_flag" && test -n "$link_static_flag"; then
 568           compile_command="$compile_command $link_static_flag"
 569           finalize_command="$finalize_command $link_static_flag"
 570         fi
 571         continue
 572         ;;
 573
 574       -version-info)
 575         prev=vinfo
 576         continue
 577         ;;
 578
 579       # Some other compiler flag.
 580       -* | +*)
 581         # Unknown arguments in both finalize_command and compile_command need
 582         # to be aesthetically quoted because they are evaled later.
 583         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
 584         case "$arg" in
 585         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*)
 586           arg="\"$arg\""
 587           ;;
 588         esac
 589         ;;
 590
 591       *.o | *.obj | *.a | *.lib)
 592         # A standard object.
 593         objs="$objs $arg"
 594         ;;
 595
 596       *.lo)
 597         # A library object.
 598         if test "$prev" = dlfiles; then
 599           dlfiles="$dlfiles $arg"
 600           if test "$build_libtool_libs" = yes; then
 601             prev=
 602             continue
 603           else
 604             # If libtool objects are unsupported, then we need to preload.
 605             prev=dlprefiles
 606           fi
 607         fi
 608
 609         if test "$prev" = dlprefiles; then
 610           # Preload the old-style object.
 611           dlprefiles="$dlprefiles "`$echo "X$arg" | $Xsed -e "$lo2o"`
 612           prev=
 613         fi
 614         libobjs="$libobjs $arg"
 615         ;;
 616
 617       *.la)
 618         # A libtool-controlled library.
 619
 620         dlname=
 621         libdir=
 622         library_names=
 623         old_library=
 624
 625         # Check to see that this really is a libtool archive.
 626         if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
 627         else
 628           $echo "$modename: \`$arg' is not a valid libtool archive" 1>&2
 629           exit 1
 630         fi
 631
 632         # If there is no directory component, then add one.
 633         case "$arg" in
 634         */* | *\\*) . $arg ;;
 635         *) . ./$arg ;;
 636         esac
 637
 638         # Get the name of the library we link against.
 639         linklib=
 640         for l in $old_library $library_names; do
 641           linklib="$l"
 642         done
 643
 644         if test -z "$linklib"; then
 645           $echo "$modename: cannot find name of link library for \`$arg'" 1>&2
 646           exit 1
 647         fi
 648
 649         # Find the relevant object directory and library name.
 650         name=`$echo "X$arg" | $Xsed -e 's%^.*/%%' -e 's/\.la$//' -e 's/^lib//'`
 651         dir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
 652         if test "X$dir" = "X$arg"; then
 653           dir="$objdir"
 654         else
 655           dir="$dir/$objdir"
 656         fi
 657
 658         if test -z "$libdir"; then
 659           # It is a libtool convenience library, so add in its objects.
 660           convenience="$convenience $dir/$old_library"l
 661           old_convenience="$old_convenience $dir/$old_library"
 662           compile_command="$compile_command $dir/$old_library"
 663           finalize_command="$finalize_command $dir/$old_library"
 664           continue
 665         fi
 666
 667         # This library was specified with -dlopen.
 668         if test "$prev" = dlfiles; then
 669           dlfiles="$dlfiles $arg"
 670           if test -z "$dlname"; then
 671             # If there is no dlname, we need to preload.
 672             prev=dlprefiles
 673           else
 674             # We should not create a dependency on this library, but we
 675             # may need any libraries it requires.
 676             compile_command="$compile_command$dependency_libs"
 677             finalize_command="$finalize_command$dependency_libs"
 678             prev=
 679             continue
 680           fi
 681         fi
 682
 683         # The library was specified with -dlpreopen.
 684         if test "$prev" = dlprefiles; then
 685           # Prefer using a static library (so that no silly _DYNAMIC symbols
 686           # are required to link).
 687           if test -n "$old_library"; then
 688             dlprefiles="$dlprefiles $dir/$old_library"
 689           else
 690             dlprefiles="$dlprefiles $dir/$linklib"
 691           fi
 692           prev=
 693         fi
 694
 695         if test "$build_libtool_libs" = yes && test -n "$library_names"; then
 696           link_against_libtool_libs="$link_against_libtool_libs $arg"
 697           if test -n "$shlibpath_var"; then
 698             # Make sure the rpath contains only unique directories.
 699             case "$temp_rpath " in
 700             *" $dir "*) ;;
 701             *) temp_rpath="$temp_rpath $dir" ;;
 702             esac
 703           fi
 704
 705           # This is the magic to use -rpath.
 706           if test -n "$hardcode_libdir_flag_spec"; then
 707             if test -n "$hardcode_libdir_separator"; then
 708               if test -z "$hardcode_libdirs"; then
 709                 # Put the magic libdir with the hardcode flag.
 710                 hardcode_libdirs="$libdir"
 711                 libdir="@HARDCODE_LIBDIRS@"
 712               else
 713                 # Just accumulate the unique libdirs.
 714                 case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in
 715                 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
 716                   ;;
 717                 *)
 718                   hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 719                   ;;
 720                 esac
 721                 libdir=
 722               fi
 723             fi
 724
 725             if test -n "$libdir"; then
 726               eval flag=\"$hardcode_libdir_flag_spec\"
 727
 728               compile_command="$compile_command $flag"
 729               finalize_command="$finalize_command $flag"
 730             fi
 731           elif test -n "$runpath_var"; then
 732             # Do the same for the permanent run path.
 733             case "$perm_rpath " in
 734             *" $libdir "*) ;;
 735             *) perm_rpath="$perm_rpath $libdir" ;;
 736             esac
 737           fi
 738
 739
 740           lib_linked=yes
 741           case "$hardcode_action" in
 742           immediate | unsupported)
 743             if test "$hardcode_direct" = no; then
 744               compile_command="$compile_command $dir/$linklib"
 745             elif test "$hardcode_minus_L" = no; then
 746               compile_command="$compile_command -L$dir -l$name"
 747             elif test "$hardcode_shlibpath_var" = no; then
 748               compile_shlibpath="$compile_shlibpath$dir:"
 749               compile_command="$compile_command -l$name"
 750             else
 751               lib_linked=no
 752             fi
 753             ;;
 754
 755           relink)
 756             # We need an absolute path.
 757             case "$dir" in
 758             /* | [A-Za-z]:[/\\]*) ;;
 759             *)
 760               absdir=`cd "$dir" && pwd`
 761               if test -z "$absdir"; then
 762                 $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
 763                 exit 1
 764               fi
 765               dir="$absdir"
 766               ;;
 767             esac
 768
 769             if test "$hardcode_direct" = yes; then
 770               compile_command="$compile_command $dir/$linklib"
 771             elif test "$hardcode_minus_L" = yes; then
 772               compile_command="$compile_command -L$dir -l$name"
 773             elif test "$hardcode_shlibpath_var" = yes; then
 774               compile_shlibpath="$compile_shlibpath$dir:"
 775               compile_command="$compile_command -l$name"
 776             else
 777               lib_linked=no
 778             fi
 779             ;;
 780
 781           *)
 782             lib_linked=no
 783             ;;
 784           esac
 785
 786           if test "$lib_linked" != yes; then
 787             $echo "$modename: configuration error: unsupported hardcode properties"
 788             exit 1
 789           fi
 790
 791           # Finalize command for both is simple: just hardcode it.
 792           if test "$hardcode_direct" = yes; then
 793             finalize_command="$finalize_command $libdir/$linklib"
 794           elif test "$hardcode_minus_L" = yes; then
 795             finalize_command="$finalize_command -L$libdir -l$name"
 796           elif test "$hardcode_shlibpath_var" = yes; then
 797             finalize_shlibpath="$finalize_shlibpath$libdir:"
 798             finalize_command="$finalize_command -l$name"
 799           else
 800             # We cannot seem to hardcode it, guess we'll fake it.
 801             finalize_command="$finalize_command -L$libdir -l$name"
 802           fi
 803         else
 804           # Transform directly to old archives if we don't build new libraries.
 805           if test -n "$pic_flag" && test -z "$old_library"; then
 806             $echo "$modename: cannot find static library for \`$arg'" 1>&2
 807             exit 1
 808           fi
 809
 810           # Here we assume that one of hardcode_direct or hardcode_minus_L
 811           # is not unsupported.  This is valid on all known static and
 812           # shared platforms.
 813           if test "$hardcode_direct" != unsupported; then
 814             test -n "$old_library" && linklib="$old_library"
 815             compile_command="$compile_command $dir/$linklib"
 816             finalize_command="$finalize_command $dir/$linklib"
 817           else
 818             compile_command="$compile_command -L$dir -l$name"
 819             finalize_command="$finalize_command -L$dir -l$name"
 820           fi
 821         fi
 822
 823         # Add in any libraries that this one depends upon.
 824         compile_command="$compile_command$dependency_libs"
 825         finalize_command="$finalize_command$dependency_libs"
 826         continue
 827         ;;
 828
 829       # Some other compiler argument.
 830       *)
 831         # Unknown arguments in both finalize_command and compile_command need
 832         # to be aesthetically quoted because they are evaled later.
 833         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
 834         case "$arg" in
 835         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*)
 836           arg="\"$arg\""
 837           ;;
 838         esac
 839         ;;
 840       esac
 841
 842       # Now actually substitute the argument into the commands.
 843       if test -n "$arg"; then
 844         compile_command="$compile_command $arg"
 845         finalize_command="$finalize_command $arg"
 846       fi
 847     done
 848
 849     if test -n "$prev"; then
 850       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
 851       $echo "$help" 1>&2
 852       exit 1
 853     fi
 854
 855     oldlibs=
 856     case "$output" in
 857     "")
 858       $echo "$modename: you must specify an output file" 1>&2
 859       $echo "$help" 1>&2
 860       exit 1
 861       ;;
 862
 863     */* | *\\*)
 864       $echo "$modename: output file \`$output' must have no directory components" 1>&2
 865       $echo "$help" 1>&2
 866       exit 1
 867       ;;
 868
 869     *.a | *.lib)
 870       if test -n "$link_against_libtool_libs"; then
 871         $echo "$modename: error: cannot link libtool libraries into archives" 1>&2
 872         exit 1
 873       fi
 874
 875       if test -n "$deplibs"; then
 876         $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
 877       fi
 878
 879       if test -n "$dlfiles$dlprefiles"; then
 880         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
 881       fi
 882
 883       if test -n "$rpath"; then
 884         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
 885       fi
 886
 887       if test -n "$vinfo"; then
 888         $echo "$modename: warning: \`-version-info' is ignored for archives" 1>&2
 889       fi
 890
 891       if test -n "$release"; then
 892         $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
 893       fi
 894
 895       # Now set the variables for building old libraries.
 896       build_libtool_libs=no
 897       oldlibs="$output"
 898       ;;
 899
 900     *.la)
 901       # Make sure we only generate libraries of the form `libNAME.la'.
 902       case "$output" in
 903       lib*) ;;
 904       *)
 905         $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
 906         $echo "$help" 1>&2
 907         exit 1
 908         ;;
 909       esac
 910
 911       name=`$echo "X$output" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
 912       eval libname=\"$libname_spec\"
 913
 914       # All the library-specific variables (install_libdir is set above).
 915       library_names=
 916       old_library=
 917       dlname=
 918
 919       if test -n "$objs"; then
 920         $echo "$modename: cannot build libtool library \`$output' from non-libtool objects:$objs" 2>&1
 921         exit 1
 922       fi
 923
 924       # How the heck are we supposed to write a wrapper for a shared library?
 925       if test -n "$link_against_libtool_libs"; then
 926         $echo "$modename: error: cannot link shared libraries into libtool libraries" 1>&2
 927         exit 1
 928       fi
 929
 930       if test -n "$dlfiles$dlprefiles"; then
 931         $echo "$modename: warning: \`-dlopen' is ignored for libtool libraries" 1>&2
 932       fi
 933
 934       set dummy $rpath
 935       if test $# -gt 2; then
 936         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
 937       fi
 938       install_libdir="$2"
 939
 940       # Now set the variables for building old libraries.
 941       oldlibs="$objdir/$libname.$libext"
 942       if test -z "$rpath"; then
 943         # Building a libtool convenience library.
 944         oldlibs="$objdir/$libname.al $oldlibs"
 945         build_libtool_libs=convenience
 946
 947         if test -n "$vinfo"; then
 948           $echo "$modename: warning: \`-version-info' is ignored for convenience libraries" 1>&2
 949         fi
 950
 951         if test -n "$release"; then
 952           $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
 953         fi
 954       else
 955
 956         # Parse the version information argument.
 957         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=':'
 958         set dummy $vinfo 0 0 0
 959         IFS="$save_ifs"
 960
 961         if test -n "$8"; then
 962           $echo "$modename: too many parameters to \`-version-info'" 1>&2
 963           $echo "$help" 1>&2
 964           exit 1
 965         fi
 966
 967         current="$2"
 968         revision="$3"
 969         age="$4"
 970
 971         # Check that each of the things are valid numbers.
 972         case "$current" in
 973         0 | [1-9] | [1-9][0-9]*) ;;
 974         *)
 975           $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
 976           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
 977           exit 1
 978           ;;
 979         esac
 980
 981         case "$revision" in
 982         0 | [1-9] | [1-9][0-9]*) ;;
 983         *)
 984           $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
 985           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
 986           exit 1
 987           ;;
 988         esac
 989
 990         case "$age" in
 991         0 | [1-9] | [1-9][0-9]*) ;;
 992         *)
 993           $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
 994           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
 995           exit 1
 996           ;;
 997         esac
 998
 999         if test $age -gt $current; then
1000           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
1001           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
1002           exit 1
1003         fi
1004
1005         # Calculate the version variables.
1006         major=
1007         versuffix=
1008         verstring=
1009         case "$version_type" in
1010         none) ;;
1011
1012         linux)
1013           major=.`expr $current - $age`
1014           versuffix="$major.$age.$revision"
1015           ;;
1016
1017         osf)
1018           major=`expr $current - $age`
1019           versuffix=".$current.$age.$revision"
1020           verstring="$current.$age.$revision"
1021
1022           # Add in all the interfaces that we are compatible with.
1023           loop=$age
1024           while test $loop != 0; do
1025             iface=`expr $current - $loop`
1026             loop=`expr $loop - 1`
1027             verstring="$verstring:${iface}.0"
1028           done
1029
1030           # Make executables depend on our current version.
1031           verstring="$verstring:${current}.0"
1032           ;;
1033
1034         sunos)
1035           major=".$current"
1036           versuffix=".$current.$revision"
1037           ;;
1038
1039         windows)
1040           # Like Linux, but with '-' rather than '.', since we only
1041           # want one extension on Windows 95.
1042           major=`expr $current - $age`
1043           versuffix="-$major-$age-$revision"
1044           ;;
1045
1046         *)
1047           $echo "$modename: unknown library version type \`$version_type'" 1>&2
1048           echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
1049           exit 1
1050           ;;
1051         esac
1052
1053         # Clear the version info if we defaulted, and they specified a release.
1054         if test -z "$vinfo" && test -n "$release"; then
1055           major=
1056           versuffix=
1057           verstring="0.0"
1058           case "$version_type" in
1059           sunos)
1060             versuffix=".0.0"
1061             ;;
1062           esac
1063         fi
1064
1065         # Check to see if the archive will have undefined symbols.
1066         if test "$allow_undefined" = yes; then
1067           if test "$allow_undefined_flag" = unsupported; then
1068             $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
1069             build_libtool_libs=no
1070             build_old_libs=yes
1071           fi
1072         else
1073           # Don't allow undefined symbols.
1074           allow_undefined_flag="$no_undefined_flag"
1075         fi
1076
1077         # Add libc to deplibs on all systems.
1078         dependency_libs="$deplibs"
1079         deplibs="$deplibs -lc"
1080       fi
1081
1082       # Create the output directory, or remove our outputs if we need to.
1083       if test -d $objdir; then
1084         $show "${rm}r $objdir/$output $objdir/$libname.* $objdir/${libname}${release}.*"
1085         $run ${rm}r $objdir/$output $objdir/$libname.* $objdir/${libname}${release}.*
1086       else
1087         $show "$mkdir $objdir"
1088         $run $mkdir $objdir
1089         status=$?
1090         if test $status -ne 0 && test ! -d $objdir; then
1091           exit $status
1092         fi
1093       fi
1094
1095       if test "$build_libtool_libs" = yes; then
1096         # Get the real and link names of the library.
1097         eval library_names=\"$library_names_spec\"
1098         set dummy $library_names
1099         realname="$2"
1100         shift; shift
1101
1102         if test -n "$soname_spec"; then
1103           eval soname=\"$soname_spec\"
1104         else
1105           soname="$realname"
1106         fi
1107
1108         lib="$objdir/$realname"
1109         for link
1110         do
1111           linknames="$linknames $link"
1112         done
1113
1114         # Use standard objects if they are PIC.
1115         test -z "$pic_flag" && libobjs=`$echo "X$libobjs " | $Xsed -e "$los2o" -e 's/ $//g'`
1116
1117         # Transform .lo files to .o files.
1118         test "$build_old_libs" = yes && oldobjs="$objs"`$echo "X$libobjs " | $Xsed -e 's/[^   ]*\.a //g' -e 's/[^   ]*\.lib //g' -e "$los2o" -e 's/ $//g'`
1119
1120         if test -n "$whole_archive_flag_spec"; then
1121           if test -n "$convenience"; then
1122             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
1123           fi
1124         else
1125           for xlib in $convenience; do
1126             # Extract the objects.
1127             xdir="$xlib"x
1128             generated="$generated $xdir"
1129             xlib=`echo "$xlib" | $Xsed -e 's%^.*/%%'`
1130
1131             $show "${rm}r $xdir"
1132             $run ${rm}r "$xdir"
1133             $show "mkdir $xdir"
1134             $run mkdir "$xdir"
1135             status=$?
1136             if test $status -ne 0 && test ! -d "$xdir"; then
1137               exit $status
1138             fi
1139             $show "(cd $xdir && $AR x ../$xlib)"
1140             $run eval "(cd \$xdir && $AR x ../\$xlib)" || exit $?
1141
1142             libobjs="$libobjs `echo $xdir/*`"
1143           done
1144         fi
1145
1146         # Do each of the archive commands.
1147         eval cmds=\"$archive_cmds\"
1148         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
1149         for cmd in $cmds; do
1150           IFS="$save_ifs"
1151           $show "$cmd"
1152           $run eval "$cmd" || exit $?
1153         done
1154         IFS="$save_ifs"
1155
1156         # Create links to the real library.
1157         for linkname in $linknames; do
1158           if test "$realname" != "$linkname"; then
1159             $show "(cd $objdir && $LN_S $realname $linkname)"
1160             $run eval '(cd $objdir && $LN_S $realname $linkname)' || exit $?
1161           fi
1162         done
1163
1164         # If -export-dynamic was specified, set the dlname.
1165         if test "$export_dynamic" = yes; then
1166           # On all known operating systems, these are identical.
1167           dlname="$soname"
1168         fi
1169       fi
1170       ;;
1171
1172     *.lo | *.o | *.obj)
1173       if test -n "$link_against_libtool_libs"; then
1174         $echo "$modename: error: cannot link libtool libraries into objects" 1>&2
1175         exit 1
1176       fi
1177
1178       if test -n "$deplibs"; then
1179         $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
1180       fi
1181
1182       if test -n "$dlfiles$dlprefiles"; then
1183         $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
1184       fi
1185
1186       if test -n "$rpath"; then
1187         $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
1188       fi
1189
1190       if test -n "$vinfo"; then
1191         $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
1192       fi
1193
1194       if test -n "$release"; then
1195         $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
1196       fi
1197
1198       case "$output" in
1199       *.lo)
1200         if test -n "$objs"; then
1201           $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
1202           exit 1
1203         fi
1204         libobj="$output"
1205         obj=`$echo "X$output" | $Xsed -e "$lo2o"`
1206         ;;
1207       *)
1208         libobj=
1209         obj="$output"
1210         ;;
1211       esac
1212
1213       # Delete the old objects.
1214       $run $rm $obj $libobj
1215
1216       # Create the old-style object.
1217       reload_objs="$objs"`$echo "X$libobjs " | $Xsed -e 's/[^       ]*\.a //g' -e 's/[^       ]*\.lib //g' -e "$los2o" -e 's/ $//g'`
1218
1219       output="$obj"
1220       eval cmds=\"$reload_cmds\"
1221       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=';'
1222       for cmd in $cmds; do
1223         IFS="$save_ifs"
1224         $show "$cmd"
1225         $run eval "$cmd" || exit $?
1226       done
1227       IFS="$save_ifs"
1228
1229       # Exit if we aren't doing a library object file.
1230       test -z "$libobj" && exit 0
1231
1232       if test "$build_libtool_libs" != yes; then
1233         # Create an invalid libtool object if no PIC, so that we don't
1234         # accidentally link it into a program.
1235         $show "echo timestamp > $libobj"
1236         $run eval "echo timestamp > $libobj" || exit $?
1237         exit 0
1238       fi
1239
1240       if test -n "$pic_flag"; then
1241         # Only do commands if we really have different PIC objects.
1242         reload_objs="$libobjs"
1243         output="$libobj"
1244         eval cmds=\"$reload_cmds\"
1245         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=';'
1246         for cmd in $cmds; do
1247           IFS="$save_ifs"
1248           $show "$cmd"
1249           $run eval "$cmd" || exit $?
1250         done
1251         IFS="$save_ifs"
1252       else
1253         # Just create a symlink.
1254         $show "$LN_S $obj $libobj"
1255         $run $LN_S $obj $libobj || exit $?
1256       fi
1257
1258       exit 0
1259       ;;
1260
1261     *)
1262       if test -n "$vinfo"; then
1263         $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
1264       fi
1265
1266       if test -n "$release"; then
1267         $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
1268       fi
1269
1270       if test -n "$rpath"; then
1271         # If the user specified any rpath flags, then add them.
1272         for libdir in $rpath; do
1273           if test -n "$hardcode_libdir_flag_spec"; then
1274             if test -n "$hardcode_libdir_separator"; then
1275               if test -z "$hardcode_libdirs"; then
1276                 # Put the magic libdir with the hardcode flag.
1277                 hardcode_libdirs="$libdir"
1278                 libdir="@HARDCODE_LIBDIRS@"
1279               else
1280                 # Just accumulate the unique libdirs.
1281                 case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in
1282                 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
1283                   ;;
1284                 *)
1285                   hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
1286                   ;;
1287                 esac
1288                 libdir=
1289               fi
1290             fi
1291
1292             if test -n "$libdir"; then
1293               eval flag=\"$hardcode_libdir_flag_spec\"
1294
1295               compile_command="$compile_command $flag"
1296               finalize_command="$finalize_command $flag"
1297             fi
1298           elif test -n "$runpath_var"; then
1299             case "$perm_rpath " in
1300             *" $libdir "*) ;;
1301             *) perm_rpath="$perm_rpath $libdir" ;;
1302             esac
1303           fi
1304         done
1305       fi
1306
1307       # Substitute the hardcoded libdirs into the compile commands.
1308       if test -n "$hardcode_libdir_separator"; then
1309         compile_command=`$echo "X$compile_command" | $Xsed -e "s%@HARDCODE_LIBDIRS@%$hardcode_libdirs%g"`
1310         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@HARDCODE_LIBDIRS@%$hardcode_libdirs%g"`
1311       fi
1312
1313       if test -n "$libobjs" && test "$build_old_libs" = yes; then
1314         # Transform all the library objects into standard objects.
1315         compile_command=`$echo "X$compile_command " | $Xsed -e "$los2o" -e 's/ $//'`
1316         finalize_command=`$echo "X$finalize_command " | $Xsed -e "$los2o" -e 's/ $//'`
1317       fi
1318
1319       if test "$export_dynamic" = yes && test -n "$NM" && test -n "$global_symbol_pipe"; then
1320         dlsyms="${output}S.c"
1321       else
1322         dlsyms=
1323       fi
1324
1325       if test -n "$dlsyms"; then
1326         # Add our own program objects to the preloaded list.
1327         dlprefiles=`$echo "X$objs$dlprefiles " | $Xsed -e "$los2o" -e 's/ $//'`
1328
1329         # Discover the nlist of each of the dlfiles.
1330         nlist="$objdir/${output}.nm"
1331
1332         if test -d $objdir; then
1333           $show "$rm $nlist ${nlist}T"
1334           $run $rm "$nlist" "${nlist}T"
1335         else
1336           $show "$mkdir $objdir"
1337           $run $mkdir $objdir
1338           status=$?
1339           if test $status -ne 0 && test ! -d $objdir; then
1340             exit $status
1341           fi
1342         fi
1343
1344         for arg in $dlprefiles; do
1345           $show "extracting global C symbols from \`$arg'"
1346           $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
1347         done
1348
1349         # Parse the name list into a source file.
1350         $show "creating $objdir/$dlsyms"
1351         if test -z "$run"; then
1352           # Make sure we at least have an empty file.
1353           test -f "$nlist" || : > "$nlist"
1354
1355           # Try sorting and uniquifying the output.
1356           if sort "$nlist" | uniq > "$nlist"T; then
1357             mv -f "$nlist"T "$nlist"
1358             wcout=`wc "$nlist" 2>/dev/null`
1359             count=`echo "X$wcout" | $Xsed -e 's/^[      ]*\([0-9][0-9]*\).*$/\1/'`
1360             (test "$count" -ge 0) 2>/dev/null || count=-1
1361           else
1362             $rm "$nlist"T
1363             count=-1
1364           fi
1365
1366           case "$dlsyms" in
1367           "") ;;
1368           *.c)
1369             $echo > "$objdir/$dlsyms" "\
1370 /* $dlsyms - symbol resolution table for \`$output' dlsym emulation. */
1371 /* Generated by $PROGRAM - GNU $PACKAGE $VERSION */
1372
1373 #ifdef __cplusplus
1374 extern \"C\" {
1375 #endif
1376
1377 /* Prevent the only kind of declaration conflicts we can make. */
1378 #define dld_preloaded_symbol_count some_other_symbol
1379 #define dld_preloaded_symbols some_other_symbol
1380
1381 /* External symbol declarations for the compiler. */\
1382 "
1383
1384             if test -f "$nlist"; then
1385               sed -e 's/^.* \(.*\)$/extern char \1;/' < "$nlist" >> "$objdir/$dlsyms"
1386             else
1387               echo '/* NONE */' >> "$objdir/$dlsyms"
1388             fi
1389
1390             $echo >> "$objdir/$dlsyms" "\
1391
1392 #undef dld_preloaded_symbol_count
1393 #undef dld_preloaded_symbols
1394
1395 #if defined (__STDC__) && __STDC__
1396 # define __ptr_t void *
1397 #else
1398 # define __ptr_t char *
1399 #endif
1400
1401 /* The number of symbols in dld_preloaded_symbols, -1 if unsorted. */
1402 int dld_preloaded_symbol_count = $count;
1403
1404 /* The mapping between symbol names and symbols. */
1405 struct {
1406   char *name;
1407   __ptr_t address;
1408 }
1409 dld_preloaded_symbols[] =
1410 {\
1411 "
1412
1413             if test -f "$nlist"; then
1414               sed 's/^\(.*\) \(.*\)$/  {"\1", (__ptr_t) \&\2},/' < "$nlist" >> "$objdir/$dlsyms"
1415             fi
1416
1417             $echo >> "$objdir/$dlsyms" "\
1418   {0, (__ptr_t) 0}
1419 };
1420
1421 #ifdef __cplusplus
1422 }
1423 #endif\
1424 "
1425             ;;
1426
1427           *)
1428             $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
1429             exit 1
1430             ;;
1431           esac
1432         fi
1433
1434         # Now compile the dynamic symbol file.
1435         $show "(cd $objdir && $CC -c$no_builtin_flag \"$dlsyms\")"
1436         $run eval '(cd $objdir && $CC -c$no_builtin_flag "$dlsyms")' || exit $?
1437
1438         # Transform the symbol file into the correct name.
1439         compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$objdir/${output}S.${objext}%"`
1440         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$objdir/${output}S.${objext}%"`
1441       elif test "$export_dynamic" != yes; then
1442         test -n "$dlfiles$dlprefiles" && $echo "$modename: warning: \`-dlopen' and \`-dlpreopen' are ignored without \`-export-dynamic'" 1>&2
1443       else
1444         # We keep going just in case the user didn't refer to
1445         # dld_preloaded_symbols.  The linker will fail if global_symbol_pipe
1446         # really was required.
1447         $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
1448
1449         # Nullify the symbol file.
1450         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
1451         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
1452       fi
1453
1454       if test -z "$link_against_libtool_libs" || test "$build_libtool_libs" != yes; then
1455         # Replace the output file specification.
1456         compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
1457         finalize_command=`$echo "X$finalize_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
1458
1459         # We have no uninstalled library dependencies, so finalize right now.
1460         $show "$compile_command"
1461         $run eval "$compile_command"
1462         exit $?
1463       fi
1464
1465       # Replace the output file specification.
1466       compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$objdir/$output"'%g'`
1467       finalize_command=`$echo "X$finalize_command" | $Xsed -e 's%@OUTPUT@%'"$objdir/$output"'T%g'`
1468
1469       # Create the binary in the object directory, then wrap it.
1470       if test ! -d $objdir; then
1471         $show "$mkdir $objdir"
1472         $run $mkdir $objdir
1473         status=$?
1474         if test $status -ne 0 && test ! -d $objdir; then
1475           exit $status
1476         fi
1477       fi
1478
1479       if test -n "$shlibpath_var"; then
1480         # We should set the shlibpath_var
1481         rpath=
1482         for dir in $temp_rpath; do
1483           case "$dir" in
1484           /* | [A-Za-z]:[/\\]*)
1485             # Absolute path.
1486             rpath="$rpath$dir:"
1487             ;;
1488           *)
1489             # Relative path: add a thisdir entry.
1490             rpath="$rpath\$thisdir/$dir:"
1491             ;;
1492           esac
1493         done
1494         temp_rpath="$rpath"
1495       fi
1496
1497       # Delete the old output file.
1498       $run $rm $output
1499
1500       if test -n "$compile_shlibpath"; then
1501         compile_command="$shlibpath_var=\"$compile_shlibpath\$$shlibpath_var\" $compile_command"
1502       fi
1503       if test -n "$finalize_shlibpath"; then
1504         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
1505       fi
1506
1507       if test -n "$runpath_var" && test -n "$perm_rpath"; then
1508         # We should set the runpath_var.
1509         rpath=
1510         for dir in $perm_rpath; do
1511           rpath="$rpath$dir:"
1512         done
1513         compile_command="$runpath_var=\"$rpath\$$runpath_var\" $compile_command"
1514         finalize_command="$runpath_var=\"$rpath\$$runpath_var\" $finalize_command"
1515       fi
1516
1517       if test "$hardcode_action" = relink; then
1518         # AGH! Flame the AIX and HP-UX people for me, will ya?
1519         $echo "$modename: warning: using a buggy system linker" 1>&2
1520         $echo "$modename: relinking will be required before \`$output' can be installed" 1>&2
1521       fi
1522
1523       $show "$compile_command"
1524       $run eval "$compile_command" || exit $?
1525
1526       # Now create the wrapper script.
1527       $show "creating $output"
1528
1529       # Quote the finalize command for shipping.
1530       finalize_command=`$echo "X$finalize_command" | $Xsed -e "$sed_quote_subst"`
1531
1532       # Quote $echo for shipping.
1533       qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
1534
1535       # Only actually do things if our run command is non-null.
1536       if test -z "$run"; then
1537         $rm $output
1538         trap "$rm $output; exit 1" 1 2 15
1539
1540         $echo > $output "\
1541 #! $SHELL
1542
1543 # $output - temporary wrapper script for $objdir/$output
1544 # Generated by $PROGRAM - GNU $PACKAGE $VERSION
1545 #
1546 # The $output program cannot be directly executed until all the libtool
1547 # libraries that it depends on are installed.
1548 #
1549 # This wrapper script should never be moved out of \``pwd`'.
1550 # If it is, it will not operate correctly.
1551
1552 # Sed substitution that helps us do robust quoting.  It backslashifies
1553 # metacharacters that are still active within double-quoted strings.
1554 Xsed='sed -e s/^X//'
1555 sed_quote_subst='$sed_quote_subst'
1556
1557 # The HP-UX ksh and POSIX shell print the target directory to stdout
1558 # if CDPATH is set.
1559 if test \"\${CDPATH+set}\" = set; then CDPATH=; export CDPATH; fi
1560
1561 # This environment variable determines our operation mode.
1562 if test \"\$libtool_install_magic\" = \"$magic\"; then
1563   # install mode needs the following variables:
1564   link_against_libtool_libs='$link_against_libtool_libs'
1565   finalize_command=\"$finalize_command\"
1566 else
1567   # When we are sourced in execute mode, \$file and \$echo are already set.
1568   if test \"\$libtool_execute_magic\" != \"$magic\"; then
1569     echo=\"$qecho\"
1570     file=\"\$0\"
1571     # Make sure echo works.
1572     if test \"X\$1\" = X--no-reexec; then
1573       # Discard the --no-reexec flag, and continue.
1574       shift
1575     elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
1576       # Yippee, \$echo works!
1577       :
1578     else
1579       # Restart under the correct shell, and then maybe \$echo will work.
1580       exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
1581     fi
1582   fi\
1583 "
1584         $echo >> $output "\
1585
1586   # Find the directory that this script lives in.
1587   thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
1588   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
1589
1590   # Follow symbolic links until we get to the real thisdir.
1591   file=\`ls -ld \"\$file\" | sed -n 's/.*-> //p'\`
1592   while test -n \"\$file\"; do
1593     destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
1594
1595     # If there was a directory component, then change thisdir.
1596     if test \"x\$destdir\" != \"x\$file\"; then
1597       case \"\$destdir\" in
1598       /* | [A-Za-z]:[/\\]*) thisdir=\"\$destdir\" ;;
1599       *) thisdir=\"\$thisdir/\$destdir\" ;;
1600       esac
1601     fi
1602
1603     file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
1604     file=\`ls -ld \"\$thisdir/\$file\" | sed -n 's/.*-> //p'\`
1605   done
1606
1607   # Try to get the absolute directory name.
1608   absdir=\`cd \"\$thisdir\" && pwd\`
1609   test -n \"\$absdir\" && thisdir=\"\$absdir\"
1610
1611   progdir=\"\$thisdir/$objdir\"
1612   program='$output'
1613
1614   if test -f \"\$progdir/\$program\"; then"
1615
1616         # Export our shlibpath_var if we have one.
1617         if test -n "$shlibpath_var" && test -n "$temp_rpath"; then
1618           $echo >> $output "\
1619     # Add our own library path to $shlibpath_var
1620     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
1621
1622     # Some systems cannot cope with colon-terminated $shlibpath_var
1623     $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/:*\$//'\`
1624
1625     export $shlibpath_var
1626 "
1627         fi
1628
1629         $echo >> $output "\
1630     if test \"\$libtool_execute_magic\" != \"$magic\"; then
1631       # Run the actual program with our arguments.
1632
1633       # Export the path to the program.
1634       PATH=\"\$progdir:\$PATH\"
1635       export PATH
1636
1637       exec \$program \${1+\"\$@\"}
1638
1639       \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
1640       exit 1
1641     fi
1642   else
1643     # The program doesn't exist.
1644     \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
1645     \$echo \"This script is just a wrapper for \$program.\" 1>&2
1646     echo \"See the $PACKAGE documentation for more information.\" 1>&2
1647     exit 1
1648   fi
1649 fi\
1650 "
1651         chmod +x $output
1652       fi
1653       exit 0
1654       ;;
1655     esac
1656
1657     # See if we need to build an old-fashioned archive.
1658     for oldlib in $oldlibs; do
1659
1660       if test "$build_libtool_libs" = convenience; then
1661         oldobjs="$libobjs"
1662         addlibs="$convenience"
1663         build_libtool_libs=no
1664       else
1665         addlibs="$old_convenience"
1666       fi
1667
1668       # Add in members from convenience archives.
1669       for xlib in $addlibs; do
1670         # Extract the objects.
1671         xdir="$xlib"x
1672         generated="$generated $xdir"
1673         xlib=`echo "$xlib" | $Xsed -e 's%^.*/%%'`
1674
1675         $show "${rm}r $xdir"
1676         $run ${rm}r "$xdir"
1677         $show "mkdir $xdir"
1678         $run mkdir "$xdir"
1679         status=$?
1680         if test $status -ne 0 && test ! -d "$xdir"; then
1681           exit $status
1682         fi
1683         $show "(cd $xdir && $AR x ../$xlib)"
1684         $run eval "(cd \$xdir && $AR x ../\$xlib)" || exit $?
1685
1686         oldobjs="$oldobjs `echo $xdir/*`"
1687       done
1688
1689       # Do each command in the archive commands.
1690       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
1691         eval cmds=\"$old_archive_from_new_cmds\"
1692       else
1693         eval cmds=\"$old_archive_cmds\"
1694       fi
1695       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=';'
1696       for cmd in $cmds; do
1697         IFS="$save_ifs"
1698         $show "$cmd"
1699         $run eval "$cmd" || exit $?
1700       done
1701       IFS="$save_ifs"
1702     done
1703
1704     if test -n "$generated"; then
1705       $show "${rm}r$generated"
1706       $run ${rm}r$generated
1707     fi
1708
1709     # Now create the libtool archive.
1710     case "$output" in
1711     *.la)
1712       old_library=
1713       test "$build_old_libs" = yes && old_library="$libname.$libext"
1714       $show "creating $output"
1715
1716       # Only create the output if not a dry run.
1717       if test -z "$run"; then
1718         $echo > $output "\
1719 # $output - a libtool library file
1720 # Generated by $PROGRAM - GNU $PACKAGE $VERSION
1721
1722 # The name that we can dlopen(3).
1723 dlname='$dlname'
1724
1725 # Names of this library.
1726 library_names='$library_names'
1727
1728 # The name of the static archive.
1729 old_library='$old_library'
1730
1731 # Libraries that this one depends upon.
1732 dependency_libs='$dependency_libs'
1733
1734 # Version information for $libname.
1735 current=$current
1736 age=$age
1737 revision=$revision
1738
1739 # Directory that this library needs to be installed in:
1740 libdir='$install_libdir'\
1741 "
1742       fi
1743
1744       # Do a symbolic link so that the libtool archive can be found in
1745       # LD_LIBRARY_PATH before the program is installed.
1746       $show "(cd $objdir && $LN_S ../$output $output)"
1747       $run eval "(cd $objdir && $LN_S ../$output $output)" || exit $?
1748       ;;
1749     esac
1750     exit 0
1751     ;;
1752
1753   # libtool install mode
1754   install)
1755     modename="$modename: install"
1756
1757     # There may be an optional sh(1) argument at the beginning of
1758     # install_prog (especially on Windows NT).
1759     if test "$nonopt" = "$SHELL"; then
1760       # Aesthetically quote it.
1761       arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
1762       case "$arg" in
1763       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
1764         arg="\"$arg\""
1765         ;;
1766       esac
1767       install_prog="$arg "
1768       arg="$1"
1769       shift
1770     else
1771       install_prog=
1772       arg="$nonopt"
1773     fi
1774
1775     # The real first argument should be the name of the installation program.
1776     # Aesthetically quote it.
1777     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1778     case "$arg" in
1779     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*)
1780       arg="\"$arg\""
1781       ;;
1782     esac
1783     install_prog="$install_prog$arg"
1784
1785     # We need to accept at least all the BSD install flags.
1786     dest=
1787     files=
1788     opts=
1789     prev=
1790     install_type=
1791     isdir=no
1792     stripme=
1793     for arg
1794     do
1795       if test -n "$dest"; then
1796         files="$files $dest"
1797         dest="$arg"
1798         continue
1799       fi
1800
1801       case "$arg" in
1802       -d) isdir=yes ;;
1803       -f) prev="-f" ;;
1804       -g) prev="-g" ;;
1805       -m) prev="-m" ;;
1806       -o) prev="-o" ;;
1807       -s)
1808         stripme=" -s"
1809         continue
1810         ;;
1811       -*) ;;
1812
1813       *)
1814         # If the previous option needed an argument, then skip it.
1815         if test -n "$prev"; then
1816           prev=
1817         else
1818           dest="$arg"
1819           continue
1820         fi
1821         ;;
1822       esac
1823
1824       # Aesthetically quote the argument.
1825       arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1826       case "$arg" in
1827       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
1828         arg="\"$arg\""
1829         ;;
1830       esac
1831       install_prog="$install_prog $arg"
1832     done
1833
1834     if test -z "$install_prog"; then
1835       $echo "$modename: you must specify an install program" 1>&2
1836       $echo "$help" 1>&2
1837       exit 1
1838     fi
1839
1840     if test -n "$prev"; then
1841       $echo "$modename: the \`$prev' option requires an argument" 1>&2
1842       $echo "$help" 1>&2
1843       exit 1
1844     fi
1845
1846     if test -z "$files"; then
1847       if test -z "$dest"; then
1848         $echo "$modename: no file or destination specified" 1>&2
1849       else
1850         $echo "$modename: you must specify a destination" 1>&2
1851       fi
1852       $echo "$help" 1>&2
1853       exit 1
1854     fi
1855
1856     # Strip any trailing slash from the destination.
1857     dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
1858
1859     # Check to see that the destination is a directory.
1860     test -d "$dest" && isdir=yes
1861     if test "$isdir" = yes; then
1862       destdir="$dest"
1863       destname=
1864     else
1865       destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
1866       test "X$destdir" = "X$dest" && destdir=.
1867       destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
1868
1869       # Not a directory, so check to see that there is only one file specified.
1870       set dummy $files
1871       if test $# -gt 2; then
1872         $echo "$modename: \`$dest' is not a directory" 1>&2
1873         $echo "$help" 1>&2
1874         exit 1
1875       fi
1876     fi
1877     case "$destdir" in
1878     /* | [A-Za-z]:[/\\]*) ;;
1879     *)
1880       for file in $files; do
1881         case "$file" in
1882         *.lo) ;;
1883         *)
1884           $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
1885           $echo "$help" 1>&2
1886           exit 1
1887           ;;
1888         esac
1889       done
1890       ;;
1891     esac
1892
1893     # This variable tells wrapper scripts just to set variables rather
1894     # than running their programs.
1895     libtool_install_magic="$magic"
1896
1897     staticlibs=
1898     future_libdirs=
1899     current_libdirs=
1900     for file in $files; do
1901
1902       # Do each installation.
1903       case "$file" in
1904       *.a | *.lib)
1905         # Do the static libraries later.
1906         staticlibs="$staticlibs $file"
1907         ;;
1908
1909       *.la)
1910         # Check to see that this really is a libtool archive.
1911         if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
1912         else
1913           $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
1914           $echo "$help" 1>&2
1915           exit 1
1916         fi
1917
1918         library_names=
1919         old_library=
1920         # If there is no directory component, then add one.
1921         case "$file" in
1922         */* | *\\*) . $file ;;
1923         *) . ./$file ;;
1924         esac
1925
1926         # Add the libdir to current_libdirs if it is the destination.
1927         if test "X$destdir" = "X$libdir"; then
1928           case "$current_libdirs " in
1929           *" $libdir "*) ;;
1930           *) current_libdirs="$current_libdirs $libdir" ;;
1931           esac
1932         else
1933           # Note the libdir as a future libdir.
1934           case "$future_libdirs " in
1935           *" $libdir "*) ;;
1936           *) future_libdirs="$future_libdirs $libdir" ;;
1937           esac
1938         fi
1939
1940         dir="`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/"
1941         test "X$dir" = "X$file/" && dir=
1942         dir="$dir$objdir"
1943
1944         # See the names of the shared library.
1945         set dummy $library_names
1946         if test -n "$2"; then
1947           realname="$2"
1948           shift
1949           shift
1950
1951           # Install the shared library and build the symlinks.
1952           $show "$install_prog $dir/$realname $destdir/$realname"
1953           $run eval "$install_prog $dir/$realname $destdir/$realname" || exit $?
1954           test "X$dlname" = "X$realname" && dlname=
1955
1956           if test $# -gt 0; then
1957             # Delete the old symlinks.
1958             rmcmd="$rm"
1959             for linkname
1960             do
1961               if test "X$linkname" != "X$realname"; then
1962                 rmcmd="$rmcmd $destdir/$linkname"
1963               fi
1964             done
1965             $show "$rmcmd"
1966             $run $rmcmd
1967
1968             # ... and create new ones.
1969             for linkname
1970             do
1971               if test "X$linkname" != "X$realname"; then
1972                 test "X$dlname" = "X$linkname" && dlname=
1973                 $show "(cd $destdir && $LN_S $realname $linkname)"
1974                 $run eval "(cd $destdir && $LN_S $realname $linkname)"
1975               fi
1976             done
1977           fi
1978
1979           if test -n "$dlname"; then
1980             # Install the dynamically-loadable library.
1981             $show "$install_prog $dir/$dlname $destdir/$dlname"
1982             $run eval "$install_prog $dir/$dlname $destdir/$dlname" || exit $?
1983           fi
1984
1985           # Do each command in the postinstall commands.
1986           lib="$destdir/$realname"
1987           eval cmds=\"$postinstall_cmds\"
1988           IFS="${IFS=   }"; save_ifs="$IFS"; IFS=';'
1989           for cmd in $cmds; do
1990             IFS="$save_ifs"
1991             $show "$cmd"
1992             $run eval "$cmd" || exit $?
1993           done
1994           IFS="$save_ifs"
1995         fi
1996
1997         # Install the pseudo-library for information purposes.
1998         name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
1999         $show "$install_prog $file $destdir/$name"
2000         $run eval "$install_prog $file $destdir/$name" || exit $?
2001
2002         # Maybe install the static library, too.
2003         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2004         ;;
2005
2006       *.lo)
2007         # Install (i.e. copy) a libtool object.
2008
2009         # Figure out destination file name, if it wasn't already specified.
2010         if test -n "$destname"; then
2011           destfile="$destdir/$destname"
2012         else
2013           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
2014           destfile="$destdir/$destfile"
2015         fi
2016
2017         # Deduce the name of the destination old-style object file.
2018         case "$destfile" in
2019         *.lo)
2020           staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
2021           ;;
2022         *.o | *.obj)
2023           staticdest="$destfile"
2024           destfile=
2025           ;;
2026         *)
2027           $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
2028           $echo "$help" 1>&2
2029           exit 1
2030           ;;
2031         esac
2032
2033         # Install the libtool object if requested.
2034         if test -n "$destfile"; then
2035           $show "$install_prog $file $destfile"
2036           $run eval "$install_prog $file $destfile" || exit $?
2037         fi
2038
2039         # Install the old object if enabled.
2040         if test "$build_old_libs" = yes; then
2041           # Deduce the name of the old-style object file.
2042           staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
2043
2044           $show "$install_prog $staticobj $staticdest"
2045           $run eval "$install_prog \$staticobj \$staticdest" || exit $?
2046         fi
2047         exit 0
2048         ;;
2049
2050       *)
2051         # Figure out destination file name, if it wasn't already specified.
2052         if test -n "$destname"; then
2053           destfile="$destdir/$destname"
2054         else
2055           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
2056           destfile="$destdir/$destfile"
2057         fi
2058
2059         # Do a test to see if this is really a libtool program.
2060         if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
2061           link_against_libtool_libs=
2062           finalize_command=
2063
2064           # If there is no directory component, then add one.
2065           case "$file" in
2066           */* | *\\*) . $file ;;
2067           *) . ./$file ;;
2068           esac
2069
2070           # Check the variables that should have been set.
2071           if test -z "$link_against_libtool_libs" || test -z "$finalize_command"; then
2072             $echo "$modename: invalid libtool wrapper script \`$file'" 1>&2
2073             exit 1
2074           fi
2075
2076           finalize=yes
2077           for lib in $link_against_libtool_libs; do
2078             # Check to see that each library is installed.
2079             libdir=
2080             if test -f "$lib"; then
2081               # If there is no directory component, then add one.
2082               case "$lib" in
2083               */* | *\\*) . $lib ;;
2084               *) . ./$lib ;;
2085               esac
2086             fi
2087             libfile="$libdir/`$echo "X$lib" | $Xsed -e 's%^.*/%%g'`"
2088             if test -n "$libdir" && test ! -f "$libfile"; then
2089               $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
2090               finalize=no
2091             fi
2092           done
2093
2094           if test "$hardcode_action" = relink; then
2095             if test "$finalize" = yes; then
2096               $echo "$modename: warning: relinking \`$file' on behalf of your buggy system linker" 1>&2
2097               $show "$finalize_command"
2098               if $run eval "$finalize_command"; then :
2099               else
2100                 $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
2101                 continue
2102               fi
2103               file="$objdir/$file"T
2104             else
2105               $echo "$modename: warning: cannot relink \`$file' on behalf of your buggy system linker" 1>&2
2106             fi
2107           else
2108             # Install the binary that we compiled earlier.
2109             file=`$echo "X$file" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
2110           fi
2111         fi
2112
2113         $show "$install_prog$stripme $file $destfile"
2114         $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
2115         ;;
2116       esac
2117     done
2118
2119     for file in $staticlibs; do
2120       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
2121
2122       # Set up the ranlib parameters.
2123       oldlib="$destdir/$name"
2124
2125       $show "$install_prog $file $oldlib"
2126       $run eval "$install_prog \$file \$oldlib" || exit $?
2127
2128       # Do each command in the postinstall commands.
2129       eval cmds=\"$old_postinstall_cmds\"
2130       IFS="${IFS=       }"; save_ifs="$IFS"; IFS=';'
2131       for cmd in $cmds; do
2132         IFS="$save_ifs"
2133         $show "$cmd"
2134         $run eval "$cmd" || exit $?
2135       done
2136       IFS="$save_ifs"
2137     done
2138
2139     if test -n "$future_libdirs"; then
2140       $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
2141     fi
2142
2143     if test -n "$current_libdirs"; then
2144       # Maybe just do a dry run.
2145       test -n "$run" && current_libdirs=" -n$current_libdirs"
2146       exec $SHELL $0 --finish$current_libdirs
2147       exit 1
2148     fi
2149
2150     exit 0
2151     ;;
2152
2153   # libtool finish mode
2154   finish)
2155     modename="$modename: finish"
2156     libdirs="$nonopt"
2157     admincmds=
2158
2159     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2160       for dir
2161       do
2162         libdirs="$libdirs $dir"
2163       done
2164
2165       for libdir in $libdirs; do
2166         if test -n "$finish_cmds"; then
2167           # Do each command in the finish commands.
2168           eval cmds=\"$finish_cmds\"
2169           IFS="${IFS=   }"; save_ifs="$IFS"; IFS=';'
2170           for cmd in $cmds; do
2171             IFS="$save_ifs"
2172             $show "$cmd"
2173             $run eval "$cmd" || admincmds="$admincmds
2174        $cmd"
2175           done
2176           IFS="$save_ifs"
2177         fi
2178         if test -n "$finish_eval"; then
2179           # Do the single finish_eval.
2180           eval cmds=\"$finish_eval\"
2181           $run eval "$cmds" || admincmds="$admincmds
2182        $cmds"
2183         fi
2184       done
2185     fi
2186
2187     echo "----------------------------------------------------------------------"
2188     echo "Libraries have been installed in:"
2189     for libdir in $libdirs; do
2190       echo "   $libdir"
2191     done
2192     echo
2193     echo "To link against installed libraries in a given directory, LIBDIR,"
2194     echo "you must use the \`-LLIBDIR' flag during linking."
2195     echo
2196     echo " You will also need to do at least one of the following:"
2197     if test -n "$shlibpath_var"; then
2198       echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
2199       echo "     during execution"
2200     fi
2201     if test -n "$runpath_var"; then
2202       echo "   - add LIBDIR to the \`$runpath_var' environment variable"
2203       echo "     during linking"
2204     fi
2205     if test -n "$hardcode_libdir_flag_spec"; then
2206       libdir=LIBDIR
2207       eval flag=\"$hardcode_libdir_flag_spec\"
2208
2209       echo "   - use the \`$flag' linker flag"
2210     fi
2211     if test -n "$admincmds"; then
2212       echo "   - have your system administrator run these commands:$admincmds"
2213     fi
2214     if test -f /etc/ld.so.conf; then
2215       echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2216     fi
2217     echo
2218     echo "See any operating system documentation about shared libraries for"
2219     echo "more information, such as the ld(1) and ld.so(8) manual pages."
2220     echo "----------------------------------------------------------------------"
2221     exit 0
2222     ;;
2223
2224   # libtool execute mode
2225   execute)
2226     modename="$modename: execute"
2227
2228     # The first argument is the command name.
2229     cmd="$nonopt"
2230     if test -z "$cmd"; then
2231       $echo "$modename: you must specify a COMMAND" 1>&2
2232       $echo "$help"
2233       exit 1
2234     fi
2235
2236     # Handle -dlopen flags immediately.
2237     for file in $execute_dlfiles; do
2238       if test ! -f "$file"; then
2239         $echo "$modename: \`$file' is not a file" 1>&2
2240         $echo "$help" 1>&2
2241         exit 1
2242       fi
2243
2244       dir=
2245       case "$file" in
2246       *.la)
2247         # Check to see that this really is a libtool archive.
2248         if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
2249         else
2250           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2251           $echo "$help" 1>&2
2252           exit 1
2253         fi
2254
2255         # Read the libtool library.
2256         dlname=
2257         library_names=
2258
2259         # If there is no directory component, then add one.
2260         case "$file" in
2261         */* | *\\*) . $file ;;
2262         *) . ./$file ;;
2263         esac
2264
2265         # Skip this library if it cannot be dlopened.
2266         if test -z "$dlname"; then
2267           # Warn if it was a shared library.
2268           test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
2269           continue
2270         fi
2271
2272         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
2273         test "X$dir" = "X$file" && dir=.
2274
2275         if test -f "$dir/$objdir/$dlname"; then
2276           dir="$dir/$objdir"
2277         else
2278           $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
2279           exit 1
2280         fi
2281         ;;
2282
2283       *.lo)
2284         # Just add the directory containing the .lo file.
2285         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
2286         test "X$dir" = "X$file" && dir=.
2287         ;;
2288
2289       *)
2290         $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
2291         continue
2292         ;;
2293       esac
2294
2295       # Get the absolute pathname.
2296       absdir=`cd "$dir" && pwd`
2297       test -n "$absdir" && dir="$absdir"
2298
2299       # Now add the directory to shlibpath_var.
2300       if eval "test -z \"\$$shlibpath_var\""; then
2301         eval "$shlibpath_var=\"\$dir\""
2302       else
2303         eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2304       fi
2305     done
2306
2307     # This variable tells wrapper scripts just to set shlibpath_var
2308     # rather than running their programs.
2309     libtool_execute_magic="$magic"
2310
2311     # Check if any of the arguments is a wrapper script.
2312     args=
2313     for file
2314     do
2315       case "$file" in
2316       -*) ;;
2317       *)
2318         # Do a test to see if this is really a libtool program.
2319         if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
2320           # If there is no directory component, then add one.
2321           case "$file" in
2322           */* | *\\*) . $file ;;
2323           *) . ./$file ;;
2324           esac
2325
2326           # Transform arg to wrapped name.
2327           file="$progdir/$program"
2328         fi
2329         ;;
2330       esac
2331       # Quote arguments (to preserve shell metacharacters).
2332       file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
2333       args="$args \"$file\""
2334     done
2335
2336     if test -z "$run"; then
2337       # Export the shlibpath_var.
2338       eval "export $shlibpath_var"
2339
2340       # Restore saved enviroment variables
2341       if test "${save_LC_ALL+set}" = set; then
2342         LC_ALL="$save_LC_ALL"; export LC_ALL
2343       fi
2344       if test "${save_LANG+set}" = set; then
2345         LANG="$save_LANG"; export LANG
2346       fi
2347
2348       # Now actually exec the command.
2349       eval "exec \$cmd$args"
2350
2351       $echo "$modename: cannot exec \$cmd$args"
2352       exit 1
2353     else
2354       # Display what would be done.
2355       eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
2356       $echo "export $shlibpath_var"
2357       $echo "$cmd$args"
2358       exit 0
2359     fi
2360     ;;
2361
2362   # libtool uninstall mode
2363   uninstall)
2364     modename="$modename: uninstall"
2365     rm="$nonopt"
2366     files=
2367
2368     for arg
2369     do
2370       case "$arg" in
2371       -*) rm="$rm $arg" ;;
2372       *) files="$files $arg" ;;
2373       esac
2374     done
2375
2376     if test -z "$rm"; then
2377       $echo "$modename: you must specify an RM program" 1>&2
2378       $echo "$help" 1>&2
2379       exit 1
2380     fi
2381
2382     for file in $files; do
2383       dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
2384       test "X$dir" = "X$file" && dir=.
2385       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
2386
2387       rmfiles="$file"
2388
2389       case "$name" in
2390       *.la)
2391         # Possibly a libtool archive, so verify it.
2392         if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
2393           . $dir/$name
2394
2395           # Delete the libtool libraries and symlinks.
2396           for n in $library_names; do
2397             rmfiles="$rmfiles $dir/$n"
2398             test "X$n" = "X$dlname" && dlname=
2399           done
2400           test -n "$dlname" && rmfiles="$rmfiles $dir/$dlname"
2401           test -n "$old_library" && rmfiles="$rmfiles $dir/$old_library"
2402
2403           $show "$rm $rmfiles"
2404           $run $rm $rmfiles
2405
2406           if test -n "$library_names"; then
2407             # Do each command in the postuninstall commands.
2408             eval cmds=\"$postuninstall_cmds\"
2409             IFS="${IFS=         }"; save_ifs="$IFS"; IFS=';'
2410             for cmd in $cmds; do
2411               IFS="$save_ifs"
2412               $show "$cmd"
2413               $run eval "$cmd"
2414             done
2415             IFS="$save_ifs"
2416           fi
2417
2418           if test -n "$old_library"; then
2419             # Do each command in the old_postuninstall commands.
2420             eval cmds=\"$old_postuninstall_cmds\"
2421             IFS="${IFS=         }"; save_ifs="$IFS"; IFS=';'
2422             for cmd in $cmds; do
2423               IFS="$save_ifs"
2424               $show "$cmd"
2425               $run eval "$cmd"
2426             done
2427             IFS="$save_ifs"
2428           fi
2429
2430           # FIXME: should reinstall the best remaining shared library.
2431         fi
2432         ;;
2433
2434       *.lo)
2435         if test "$build_old_libs" = yes; then
2436           oldobj=`$echo "X$name" | $Xsed -e "$lo2o"`
2437           rmfiles="$rmfiles $dir/$oldobj"
2438         fi
2439         $show "$rm $rmfiles"
2440         $run $rm $rmfiles
2441         ;;
2442
2443       *)
2444         $show "$rm $rmfiles"
2445         $run $rm $rmfiles
2446         ;;
2447       esac
2448     done
2449     exit 0
2450     ;;
2451
2452   "")
2453     $echo "$modename: you must specify a MODE" 1>&2
2454     $echo "$generic_help" 1>&2
2455     exit 1
2456     ;;
2457   esac
2458
2459   $echo "$modename: invalid operation mode \`$mode'" 1>&2
2460   $echo "$generic_help" 1>&2
2461   exit 1
2462 fi # test -z "$show_help"
2463
2464 # We need to display help for each of the modes.
2465 case "$mode" in
2466 "") $echo \
2467 "Usage: $modename [OPTION]... [MODE-ARG]...
2468
2469 Provide generalized library-building support services.
2470
2471     --config          show all configuration variables
2472     --debug           enable verbose shell tracing
2473 -n, --dry-run         display commands without modifying any files
2474     --features        display basic configuration information and exit
2475     --finish          same as \`--mode=finish'
2476     --help            display this help message and exit
2477     --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
2478     --quiet           same as \`--silent'
2479     --silent          don't print informational messages
2480     --version         print version information
2481
2482 MODE must be one of the following:
2483
2484       compile         compile a source file into a libtool object
2485       execute         automatically set library path, then run a program
2486       finish          complete the installation of libtool libraries
2487       install         install libraries or executables
2488       link            create a library or an executable
2489       uninstall       remove libraries from an installed directory
2490
2491 MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
2492 a more detailed description of MODE."
2493   exit 0
2494   ;;
2495
2496 compile)
2497   $echo \
2498 "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
2499
2500 Compile a source file into a libtool library object.
2501
2502 This mode accepts the following additional options:
2503
2504   -static           always build a \`.o' file suitable for static linking
2505
2506 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
2507 from the given SOURCEFILE.
2508
2509 The output file name is determined by removing the directory component from
2510 SOURCEFILE, then substituting the C source code suffix \`.c' with the
2511 library object suffix, \`.lo'."
2512   ;;
2513
2514 execute)
2515   $echo \
2516 "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
2517
2518 Automatically set library path, then run a program.
2519
2520 This mode accepts the following additional options:
2521
2522   -dlopen FILE      add the directory containing FILE to the library path
2523
2524 This mode sets the library path environment variable according to \`-dlopen'
2525 flags.
2526
2527 If any of the ARGS are libtool executable wrappers, then they are translated
2528 into their corresponding uninstalled binary, and any of their required library
2529 directories are added to the library path.
2530
2531 Then, COMMAND is executed, with ARGS as arguments."
2532   ;;
2533
2534 finish)
2535   $echo \
2536 "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
2537
2538 Complete the installation of libtool libraries.
2539
2540 Each LIBDIR is a directory that contains libtool libraries.
2541
2542 The commands that this mode executes may require superuser privileges.  Use
2543 the \`--dry-run' option if you just want to see what would be executed."
2544   ;;
2545
2546 install)
2547   $echo \
2548 "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
2549
2550 Install executables or libraries.
2551
2552 INSTALL-COMMAND is the installation command.  The first component should be
2553 either the \`install' or \`cp' program.
2554
2555 The rest of the components are interpreted as arguments to that command (only
2556 BSD-compatible install options are recognized)."
2557   ;;
2558
2559 link)
2560   $echo \
2561 "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
2562
2563 Link object files or libraries together to form another library, or to
2564 create an executable program.
2565
2566 LINK-COMMAND is a command using the C compiler that you would use to create
2567 a program from several object files.
2568
2569 The following components of LINK-COMMAND are treated specially:
2570
2571   -all-static       do not do any dynamic linking at all
2572   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
2573   -dlpreopen FILE   link in FILE and add its symbols to dld_preloaded_symbols
2574   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2575   -LLIBDIR          search LIBDIR for required installed libraries
2576   -lNAME            OUTPUT-FILE requires the installed library libNAME
2577   -no-undefined     declare that a library does not refer to external symbols
2578   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
2579   -release RELEASE  specify package release information
2580   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
2581   -static           do not do any dynamic linking of libtool libraries
2582   -version-info CURRENT[:REVISION[:AGE]]
2583                     specify library version info [each variable defaults to 0]
2584
2585 All other options (arguments beginning with \`-') are ignored.
2586
2587 Every other argument is treated as a filename.  Files ending in \`.la' are
2588 treated as uninstalled libtool libraries, other files are standard or library
2589 object files.
2590
2591 If the OUTPUT-FILE ends in \`.la', then a libtool library is created, only
2592 library objects (\`.lo' files) may be specified, and \`-rpath' is required.
2593
2594 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2595 using \`ar' and \`ranlib', or on WIndows using \`lib'.
2596
2597 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2598 is created, otherwise an executable program is created."
2599   ;;
2600
2601 uninstall)
2602   $echo
2603 "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2604
2605 Remove libraries from an installation directory.
2606
2607 RM is the name of the program to use to delete files associated with each FILE
2608 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
2609 to RM.
2610
2611 If FILE is a libtool library, all the files associated with it are deleted.
2612 Otherwise, only FILE itself is deleted using RM."
2613   ;;
2614
2615 *)
2616   $echo "$modename: invalid operation mode \`$mode'" 1>&2
2617   $echo "$help" 1>&2
2618   exit 1
2619   ;;
2620 esac
2621
2622 echo
2623 $echo "Try \`$modename --help' for more information about other modes."
2624
2625 exit 0
2626
2627 # Local Variables:
2628 # mode:shell-script
2629 # sh-indentation:2
2630 # End: