source/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-1999 Free Software Foundation, Inc.
   5 # Originally by 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$1" = X--fallback-echo; then
  31   # Avoid inline document here, it may be left over
  32   :
  33 elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
  34   # Yippee, $echo works!
  35   :
  36 else
  37   # Restart under the correct shell, and then maybe $echo will work.
  38   exec $SHELL "$0" --no-reexec ${1+"$@"}
  39 fi
  40
  41 if test "X$1" = X--fallback-echo; then
  42   # used as fallback echo
  43   shift
  44   cat <<EOF
  45 $*
  46 EOF
  47   exit 0
  48 fi
  49
  50 # The name of this program.
  51 progname=`$echo "$0" | sed 's%^.*/%%'`
  52 modename="$progname"
  53
  54 # Constants.
  55 PROGRAM=ltmain.sh
  56 PACKAGE=libtool
  57 VERSION=1.3.4
  58 TIMESTAMP=" (1.385.2.196 1999/12/07 21:47:57)"
  59
  60 default_mode=
  61 help="Try \`$progname --help' for more information."
  62 magic="%%%MAGIC variable%%%"
  63 mkdir="mkdir"
  64 mv="mv -f"
  65 rm="rm -f"
  66
  67 # Sed substitution that helps us do robust quoting.  It backslashifies
  68 # metacharacters that are still active within double-quoted strings.
  69 Xsed='sed -e 1s/^X//'
  70 sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
  71 SP2NL='tr \040 \012'
  72 NL2SP='tr \015\012 \040\040'
  73
  74 # NLS nuisances.
  75 # Only set LANG and LC_ALL to C if already set.
  76 # These must not be set unconditionally because not all systems understand
  77 # e.g. LANG=C (notably SCO).
  78 # We save the old values to restore during execute mode.
  79 if test "${LC_ALL+set}" = set; then
  80   save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
  81 fi
  82 if test "${LANG+set}" = set; then
  83   save_LANG="$LANG"; LANG=C; export LANG
  84 fi
  85
  86 if test "$LTCONFIG_VERSION" != "$VERSION"; then
  87   echo "$modename: ltconfig version \`$LTCONFIG_VERSION' does not match $PROGRAM version \`$VERSION'" 1>&2
  88   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  89   exit 1
  90 fi
  91
  92 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
  93   echo "$modename: not configured to build any kind of library" 1>&2
  94   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  95   exit 1
  96 fi
  97
  98 # Global variables.
  99 mode=$default_mode
 100 nonopt=
 101 prev=
 102 prevopt=
 103 run=
 104 show="$echo"
 105 show_help=
 106 execute_dlfiles=
 107 lo2o="s/\\.lo\$/.${objext}/"
 108 o2lo="s/\\.${objext}\$/.lo/"
 109
 110 # Parse our command line options once, thoroughly.
 111 while test $# -gt 0
 112 do
 113   arg="$1"
 114   shift
 115
 116   case "$arg" in
 117   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
 118   *) optarg= ;;
 119   esac
 120
 121   # If the previous option needs an argument, assign it.
 122   if test -n "$prev"; then
 123     case "$prev" in
 124     execute_dlfiles)
 125       eval "$prev=\"\$$prev \$arg\""
 126       ;;
 127     *)
 128       eval "$prev=\$arg"
 129       ;;
 130     esac
 131
 132     prev=
 133     prevopt=
 134     continue
 135   fi
 136
 137   # Have we seen a non-optional argument yet?
 138   case "$arg" in
 139   --help)
 140     show_help=yes
 141     ;;
 142
 143   --version)
 144     echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
 145     exit 0
 146     ;;
 147
 148   --config)
 149     sed -e '1,/^### BEGIN LIBTOOL CONFIG/d' -e '/^### END LIBTOOL CONFIG/,$d' $0
 150     exit 0
 151     ;;
 152
 153   --debug)
 154     echo "$progname: enabling shell trace mode"
 155     set -x
 156     ;;
 157
 158   --dry-run | -n)
 159     run=:
 160     ;;
 161
 162   --features)
 163     echo "host: $host"
 164     if test "$build_libtool_libs" = yes; then
 165       echo "enable shared libraries"
 166     else
 167       echo "disable shared libraries"
 168     fi
 169     if test "$build_old_libs" = yes; then
 170       echo "enable static libraries"
 171     else
 172       echo "disable static libraries"
 173     fi
 174     exit 0
 175     ;;
 176
 177   --finish) mode="finish" ;;
 178
 179   --mode) prevopt="--mode" prev=mode ;;
 180   --mode=*) mode="$optarg" ;;
 181
 182   --quiet | --silent)
 183     show=:
 184     ;;
 185
 186   -dlopen)
 187     prevopt="-dlopen"
 188     prev=execute_dlfiles
 189     ;;
 190
 191   -*)
 192     $echo "$modename: unrecognized option \`$arg'" 1>&2
 193     $echo "$help" 1>&2
 194     exit 1
 195     ;;
 196
 197   *)
 198     nonopt="$arg"
 199     break
 200     ;;
 201   esac
 202 done
 203
 204 if test -n "$prevopt"; then
 205   $echo "$modename: option \`$prevopt' requires an argument" 1>&2
 206   $echo "$help" 1>&2
 207   exit 1
 208 fi
 209
 210 if test -z "$show_help"; then
 211
 212   # Infer the operation mode.
 213   if test -z "$mode"; then
 214     case "$nonopt" in
 215     *cc | *++ | gcc* | *-gcc*)
 216       mode=link
 217       for arg
 218       do
 219         case "$arg" in
 220         -c)
 221            mode=compile
 222            break
 223            ;;
 224         esac
 225       done
 226       ;;
 227     *db | *dbx | *strace | *truss)
 228       mode=execute
 229       ;;
 230     *install*|cp|mv)
 231       mode=install
 232       ;;
 233     *rm)
 234       mode=uninstall
 235       ;;
 236     *)
 237       # If we have no mode, but dlfiles were specified, then do execute mode.
 238       test -n "$execute_dlfiles" && mode=execute
 239
 240       # Just use the default operation mode.
 241       if test -z "$mode"; then
 242         if test -n "$nonopt"; then
 243           $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
 244         else
 245           $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
 246         fi
 247       fi
 248       ;;
 249     esac
 250   fi
 251
 252   # Only execute mode is allowed to have -dlopen flags.
 253   if test -n "$execute_dlfiles" && test "$mode" != execute; then
 254     $echo "$modename: unrecognized option \`-dlopen'" 1>&2
 255     $echo "$help" 1>&2
 256     exit 1
 257   fi
 258
 259   # Change the help message to a mode-specific one.
 260   generic_help="$help"
 261   help="Try \`$modename --help --mode=$mode' for more information."
 262
 263   # These modes are in order of execution frequency so that they run quickly.
 264   case "$mode" in
 265   # libtool compile mode
 266   compile)
 267     modename="$modename: compile"
 268     # Get the compilation command and the source file.
 269     base_compile=
 270     lastarg=
 271     srcfile="$nonopt"
 272     suppress_output=
 273
 274     user_target=no
 275     for arg
 276     do
 277       # Accept any command-line options.
 278       case "$arg" in
 279       -o)
 280         if test "$user_target" != "no"; then
 281           $echo "$modename: you cannot specify \`-o' more than once" 1>&2
 282           exit 1
 283         fi
 284         user_target=next
 285         ;;
 286
 287       -static)
 288         build_old_libs=yes
 289         continue
 290         ;;
 291       esac
 292
 293       case "$user_target" in
 294       next)
 295         # The next one is the -o target name
 296         user_target=yes
 297         continue
 298         ;;
 299       yes)
 300         # We got the output file
 301         user_target=set
 302         libobj="$arg"
 303         continue
 304         ;;
 305       esac
 306
 307       # Accept the current argument as the source file.
 308       lastarg="$srcfile"
 309       srcfile="$arg"
 310
 311       # Aesthetically quote the previous argument.
 312
 313       # Backslashify any backslashes, double quotes, and dollar signs.
 314       # These are the only characters that are still specially
 315       # interpreted inside of double-quoted scrings.
 316       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
 317
 318       # Double-quote args containing other shell metacharacters.
 319       # Many Bourne shells cannot handle close brackets correctly in scan
 320       # sets, so we specify it separately.
 321       case "$lastarg" in
 322       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
 323         lastarg="\"$lastarg\""
 324         ;;
 325       esac
 326
 327       # Add the previous argument to base_compile.
 328       if test -z "$base_compile"; then
 329         base_compile="$lastarg"
 330       else
 331         base_compile="$base_compile $lastarg"
 332       fi
 333     done
 334
 335     case "$user_target" in
 336     set)
 337       ;;
 338     no)
 339       # Get the name of the library object.
 340       libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
 341       ;;
 342     *)
 343       $echo "$modename: you must specify a target with \`-o'" 1>&2
 344       exit 1
 345       ;;
 346     esac
 347
 348     # Recognize several different file suffixes.
 349     # If the user specifies -o file.o, it is replaced with file.lo
 350     xform='[cCFSfmso]'
 351     case "$libobj" in
 352     *.ada) xform=ada ;;
 353     *.adb) xform=adb ;;
 354     *.ads) xform=ads ;;
 355     *.asm) xform=asm ;;
 356     *.c++) xform=c++ ;;
 357     *.cc) xform=cc ;;
 358     *.cpp) xform=cpp ;;
 359     *.cxx) xform=cxx ;;
 360     *.f90) xform=f90 ;;
 361     *.for) xform=for ;;
 362     esac
 363
 364     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
 365
 366     case "$libobj" in
 367     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
 368     *)
 369       $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
 370       exit 1
 371       ;;
 372     esac
 373
 374     if test -z "$base_compile"; then
 375       $echo "$modename: you must specify a compilation command" 1>&2
 376       $echo "$help" 1>&2
 377       exit 1
 378     fi
 379
 380     # Delete any leftover library objects.
 381     if test "$build_old_libs" = yes; then
 382       removelist="$obj $libobj"
 383     else
 384       removelist="$libobj"
 385     fi
 386
 387     $run $rm $removelist
 388     trap "$run $rm $removelist; exit 1" 1 2 15
 389
 390     # Calculate the filename of the output object if compiler does
 391     # not support -o with -c
 392     if test "$compiler_c_o" = no; then
 393       output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\..*$%%'`.${objext}
 394       lockfile="$output_obj.lock"
 395       removelist="$removelist $output_obj $lockfile"
 396       trap "$run $rm $removelist; exit 1" 1 2 15
 397     else
 398       need_locks=no
 399       lockfile=
 400     fi
 401
 402     # Lock this critical section if it is needed
 403     # We use this script file to make the link, it avoids creating a new file
 404     if test "$need_locks" = yes; then
 405       until ln "$0" "$lockfile" 2>/dev/null; do
 406         $show "Waiting for $lockfile to be removed"
 407         sleep 2
 408       done
 409     elif test "$need_locks" = warn; then
 410       if test -f "$lockfile"; then
 411         echo "\
 412 *** ERROR, $lockfile exists and contains:
 413 `cat $lockfile 2>/dev/null`
 414
 415 This indicates that another process is trying to use the same
 416 temporary object file, and libtool could not work around it because
 417 your compiler does not support \`-c' and \`-o' together.  If you
 418 repeat this compilation, it may succeed, by chance, but you had better
 419 avoid parallel builds (make -j) in this platform, or get a better
 420 compiler."
 421
 422         $run $rm $removelist
 423         exit 1
 424       fi
 425       echo $srcfile > "$lockfile"
 426     fi
 427
 428     if test -n "$fix_srcfile_path"; then
 429       eval srcfile=\"$fix_srcfile_path\"
 430     fi
 431
 432     # Only build a PIC object if we are building libtool libraries.
 433     if test "$build_libtool_libs" = yes; then
 434       # Without this assignment, base_compile gets emptied.
 435       fbsd_hideous_sh_bug=$base_compile
 436
 437       # All platforms use -DPIC, to notify preprocessed assembler code.
 438       command="$base_compile $srcfile $pic_flag -DPIC"
 439       if test "$build_old_libs" = yes; then
 440         lo_libobj="$libobj"
 441         dir=`$echo "X$libobj" | $Xsed -e 's%/[^/]*$%%'`
 442         if test "X$dir" = "X$libobj"; then
 443           dir="$objdir"
 444         else
 445           dir="$dir/$objdir"
 446         fi
 447         libobj="$dir/"`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`
 448
 449         if test -d "$dir"; then
 450           $show "$rm $libobj"
 451           $run $rm $libobj
 452         else
 453           $show "$mkdir $dir"
 454           $run $mkdir $dir
 455           status=$?
 456           if test $status -ne 0 && test ! -d $dir; then
 457             exit $status
 458           fi
 459         fi
 460       fi
 461       if test "$compiler_o_lo" = yes; then
 462         output_obj="$libobj"
 463         command="$command -o $output_obj"
 464       elif test "$compiler_c_o" = yes; then
 465         output_obj="$obj"
 466         command="$command -o $output_obj"
 467       fi
 468
 469       $run $rm "$output_obj"
 470       $show "$command"
 471       if $run eval "$command"; then :
 472       else
 473         test -n "$output_obj" && $run $rm $removelist
 474         exit 1
 475       fi
 476
 477       if test "$need_locks" = warn &&
 478          test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
 479         echo "\
 480 *** ERROR, $lockfile contains:
 481 `cat $lockfile 2>/dev/null`
 482
 483 but it should contain:
 484 $srcfile
 485
 486 This indicates that another process is trying to use the same
 487 temporary object file, and libtool could not work around it because
 488 your compiler does not support \`-c' and \`-o' together.  If you
 489 repeat this compilation, it may succeed, by chance, but you had better
 490 avoid parallel builds (make -j) in this platform, or get a better
 491 compiler."
 492
 493         $run $rm $removelist
 494         exit 1
 495       fi
 496
 497       # Just move the object if needed, then go on to compile the next one
 498       if test x"$output_obj" != x"$libobj"; then
 499         $show "$mv $output_obj $libobj"
 500         if $run $mv $output_obj $libobj; then :
 501         else
 502           error=$?
 503           $run $rm $removelist
 504           exit $error
 505         fi
 506       fi
 507
 508       # If we have no pic_flag, then copy the object into place and finish.
 509       if test -z "$pic_flag" && test "$build_old_libs" = yes; then
 510         # Rename the .lo from within objdir to obj
 511         if test -f $obj; then
 512           $show $rm $obj
 513           $run $rm $obj
 514         fi
 515
 516         $show "$mv $libobj $obj"
 517         if $run $mv $libobj $obj; then :
 518         else
 519           error=$?
 520           $run $rm $removelist
 521           exit $error
 522         fi
 523
 524         xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
 525         if test "X$xdir" = "X$obj"; then
 526           xdir="."
 527         else
 528           xdir="$xdir"
 529         fi
 530         baseobj=`$echo "X$obj" | $Xsed -e "s%.*/%%"`
 531         libobj=`$echo "X$baseobj" | $Xsed -e "$o2lo"`
 532         # Now arrange that obj and lo_libobj become the same file
 533         $show "(cd $xdir && $LN_S $baseobj $libobj)"
 534         if $run eval '(cd $xdir && $LN_S $baseobj $libobj)'; then
 535           exit 0
 536         else
 537           error=$?
 538           $run $rm $removelist
 539           exit $error
 540         fi
 541       fi
 542
 543       # Allow error messages only from the first compilation.
 544       suppress_output=' >/dev/null 2>&1'
 545     fi
 546
 547     # Only build a position-dependent object if we build old libraries.
 548     if test "$build_old_libs" = yes; then
 549       command="$base_compile $srcfile"
 550       if test "$compiler_c_o" = yes; then
 551         command="$command -o $obj"
 552         output_obj="$obj"
 553       fi
 554
 555       # Suppress compiler output if we already did a PIC compilation.
 556       command="$command$suppress_output"
 557       $run $rm "$output_obj"
 558       $show "$command"
 559       if $run eval "$command"; then :
 560       else
 561         $run $rm $removelist
 562         exit 1
 563       fi
 564
 565       if test "$need_locks" = warn &&
 566          test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
 567         echo "\
 568 *** ERROR, $lockfile contains:
 569 `cat $lockfile 2>/dev/null`
 570
 571 but it should contain:
 572 $srcfile
 573
 574 This indicates that another process is trying to use the same
 575 temporary object file, and libtool could not work around it because
 576 your compiler does not support \`-c' and \`-o' together.  If you
 577 repeat this compilation, it may succeed, by chance, but you had better
 578 avoid parallel builds (make -j) in this platform, or get a better
 579 compiler."
 580
 581         $run $rm $removelist
 582         exit 1
 583       fi
 584
 585       # Just move the object if needed
 586       if test x"$output_obj" != x"$obj"; then
 587         $show "$mv $output_obj $obj"
 588         if $run $mv $output_obj $obj; then :
 589         else
 590           error=$?
 591           $run $rm $removelist
 592           exit $error
 593         fi
 594       fi
 595
 596       # Create an invalid libtool object if no PIC, so that we do not
 597       # accidentally link it into a program.
 598       if test "$build_libtool_libs" != yes; then
 599         $show "echo timestamp > $libobj"
 600         $run eval "echo timestamp > \$libobj" || exit $?
 601       else
 602         # Move the .lo from within objdir
 603         $show "$mv $libobj $lo_libobj"
 604         if $run $mv $libobj $lo_libobj; then :
 605         else
 606           error=$?
 607           $run $rm $removelist
 608           exit $error
 609         fi
 610       fi
 611     fi
 612
 613     # Unlock the critical section if it was locked
 614     if test "$need_locks" != no; then
 615       $rm "$lockfile"
 616     fi
 617
 618     exit 0
 619     ;;
 620
 621   # libtool link mode
 622   link)
 623     modename="$modename: link"
 624     case "$host" in
 625     *-*-cygwin* | *-*-mingw* | *-*-os2*)
 626       # It is impossible to link a dll without this setting, and
 627       # we shouldn't force the makefile maintainer to figure out
 628       # which system we are compiling for in order to pass an extra
 629       # flag for every libtool invokation.
 630       # allow_undefined=no
 631
 632       # FIXME: Unfortunately, there are problems with the above when trying
 633       # to make a dll which has undefined symbols, in which case not
 634       # even a static library is built.  For now, we need to specify
 635       # -no-undefined on the libtool link line when we can be certain
 636       # that all symbols are satisfied, otherwise we get a static library.
 637       allow_undefined=yes
 638
 639       # This is a source program that is used to create dlls on Windows
 640       # Don't remove nor modify the starting and closing comments
 641 # /* ltdll.c starts here */
 642 # #define WIN32_LEAN_AND_MEAN
 643 # #include <windows.h>
 644 # #undef WIN32_LEAN_AND_MEAN
 645 # #include <stdio.h>
 646 #
 647 # #ifndef __CYGWIN__
 648 # #  ifdef __CYGWIN32__
 649 # #    define __CYGWIN__ __CYGWIN32__
 650 # #  endif
 651 # #endif
 652 #
 653 # #ifdef __cplusplus
 654 # extern "C" {
 655 # #endif
 656 # BOOL APIENTRY DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved);
 657 # #ifdef __cplusplus
 658 # }
 659 # #endif
 660 #
 661 # #ifdef __CYGWIN__
 662 # #include <cygwin/cygwin_dll.h>
 663 # DECLARE_CYGWIN_DLL( DllMain );
 664 # #endif
 665 # HINSTANCE __hDllInstance_base;
 666 #
 667 # BOOL APIENTRY
 668 # DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved)
 669 # {
 670 #   __hDllInstance_base = hInst;
 671 #   return TRUE;
 672 # }
 673 # /* ltdll.c ends here */
 674       # This is a source program that is used to create import libraries
 675       # on Windows for dlls which lack them. Don't remove nor modify the
 676       # starting and closing comments
 677 # /* impgen.c starts here */
 678 # /*   Copyright (C) 1999 Free Software Foundation, Inc.
 679 #
 680 #  This file is part of GNU libtool.
 681 #
 682 #  This program is free software; you can redistribute it and/or modify
 683 #  it under the terms of the GNU General Public License as published by
 684 #  the Free Software Foundation; either version 2 of the License, or
 685 #  (at your option) any later version.
 686 #
 687 #  This program is distributed in the hope that it will be useful,
 688 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
 689 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 690 #  GNU General Public License for more details.
 691 #
 692 #  You should have received a copy of the GNU General Public License
 693 #  along with this program; if not, write to the Free Software
 694 #  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 695 #  */
 696 #
 697 #  #include <stdio.h>           /* for printf() */
 698 #  #include <unistd.h>          /* for open(), lseek(), read() */
 699 #  #include <fcntl.h>           /* for O_RDONLY, O_BINARY */
 700 #  #include <string.h>          /* for strdup() */
 701 #
 702 #  static unsigned int
 703 #  pe_get16 (fd, offset)
 704 #       int fd;
 705 #       int offset;
 706 #  {
 707 #    unsigned char b[2];
 708 #    lseek (fd, offset, SEEK_SET);
 709 #    read (fd, b, 2);
 710 #    return b[0] + (b[1]<<8);
 711 #  }
 712 #
 713 #  static unsigned int
 714 #  pe_get32 (fd, offset)
 715 #      int fd;
 716 #      int offset;
 717 #  {
 718 #    unsigned char b[4];
 719 #    lseek (fd, offset, SEEK_SET);
 720 #    read (fd, b, 4);
 721 #    return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24);
 722 #  }
 723 #
 724 #  static unsigned int
 725 #  pe_as32 (ptr)
 726 #       void *ptr;
 727 #  {
 728 #    unsigned char *b = ptr;
 729 #    return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24);
 730 #  }
 731 #
 732 #  int
 733 #  main (argc, argv)
 734 #      int argc;
 735 #      char *argv[];
 736 #  {
 737 #      int dll;
 738 #      unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
 739 #      unsigned long export_rva, export_size, nsections, secptr, expptr;
 740 #      unsigned long name_rvas, nexp;
 741 #      unsigned char *expdata, *erva;
 742 #      char *filename, *dll_name;
 743 #
 744 #      filename = argv[1];
 745 #
 746 #      dll = open(filename, O_RDONLY|O_BINARY);
 747 #      if (!dll)
 748 #       return 1;
 749 #
 750 #      dll_name = filename;
 751 #
 752 #      for (i=0; filename[i]; i++)
 753 #       if (filename[i] == '/' || filename[i] == '\\'  || filename[i] == ':')
 754 #           dll_name = filename + i +1;
 755 #
 756 #      pe_header_offset = pe_get32 (dll, 0x3c);
 757 #      opthdr_ofs = pe_header_offset + 4 + 20;
 758 #      num_entries = pe_get32 (dll, opthdr_ofs + 92);
 759 #
 760 #      if (num_entries < 1) /* no exports */
 761 #       return 1;
 762 #
 763 #      export_rva = pe_get32 (dll, opthdr_ofs + 96);
 764 #      export_size = pe_get32 (dll, opthdr_ofs + 100);
 765 #      nsections = pe_get16 (dll, pe_header_offset + 4 +2);
 766 #      secptr = (pe_header_offset + 4 + 20 +
 767 #             pe_get16 (dll, pe_header_offset + 4 + 16));
 768 #
 769 #      expptr = 0;
 770 #      for (i = 0; i < nsections; i++)
 771 #      {
 772 #       char sname[8];
 773 #       unsigned long secptr1 = secptr + 40 * i;
 774 #       unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
 775 #       unsigned long vsize = pe_get32 (dll, secptr1 + 16);
 776 #       unsigned long fptr = pe_get32 (dll, secptr1 + 20);
 777 #       lseek(dll, secptr1, SEEK_SET);
 778 #       read(dll, sname, 8);
 779 #       if (vaddr <= export_rva && vaddr+vsize > export_rva)
 780 #       {
 781 #           expptr = fptr + (export_rva - vaddr);
 782 #           if (export_rva + export_size > vaddr + vsize)
 783 #               export_size = vsize - (export_rva - vaddr);
 784 #           break;
 785 #       }
 786 #      }
 787 #
 788 #      expdata = (unsigned char*)malloc(export_size);
 789 #      lseek (dll, expptr, SEEK_SET);
 790 #      read (dll, expdata, export_size);
 791 #      erva = expdata - export_rva;
 792 #
 793 #      nexp = pe_as32 (expdata+24);
 794 #      name_rvas = pe_as32 (expdata+32);
 795 #
 796 #      printf ("EXPORTS\n");
 797 #      for (i = 0; i<nexp; i++)
 798 #      {
 799 #       unsigned long name_rva = pe_as32 (erva+name_rvas+i*4);
 800 #       printf ("\t%s @ %ld ;\n", erva+name_rva, 1+ i);
 801 #      }
 802 #
 803 #      return 0;
 804 #  }
 805 # /* impgen.c ends here */
 806       ;;
 807     *)
 808       allow_undefined=yes
 809       ;;
 810     esac
 811     compile_command="$nonopt"
 812     finalize_command="$nonopt"
 813
 814     compile_rpath=
 815     finalize_rpath=
 816     compile_shlibpath=
 817     finalize_shlibpath=
 818     convenience=
 819     old_convenience=
 820     deplibs=
 821     linkopts=
 822
 823     if test -n "$shlibpath_var"; then
 824       # get the directories listed in $shlibpath_var
 825       eval lib_search_path=\`\$echo \"X \${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
 826     else
 827       lib_search_path=
 828     fi
 829     # now prepend the system-specific ones
 830     eval lib_search_path=\"$sys_lib_search_path_spec\$lib_search_path\"
 831     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
 832
 833     avoid_version=no
 834     dlfiles=
 835     dlprefiles=
 836     dlself=no
 837     export_dynamic=no
 838     export_symbols=
 839     export_symbols_regex=
 840     generated=
 841     libobjs=
 842     link_against_libtool_libs=
 843     ltlibs=
 844     module=no
 845     objs=
 846     prefer_static_libs=no
 847     preload=no
 848     prev=
 849     prevarg=
 850     release=
 851     rpath=
 852     xrpath=
 853     perm_rpath=
 854     temp_rpath=
 855     thread_safe=no
 856     vinfo=
 857
 858     # We need to know -static, to get the right output filenames.
 859     for arg
 860     do
 861       case "$arg" in
 862       -all-static | -static)
 863         if test "X$arg" = "X-all-static"; then
 864           if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
 865             $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
 866           fi
 867           if test -n "$link_static_flag"; then
 868             dlopen_self=$dlopen_self_static
 869           fi
 870         else
 871           if test -z "$pic_flag" && test -n "$link_static_flag"; then
 872             dlopen_self=$dlopen_self_static
 873           fi
 874         fi
 875         build_libtool_libs=no
 876         build_old_libs=yes
 877         prefer_static_libs=yes
 878         break
 879         ;;
 880       esac
 881     done
 882
 883     # See if our shared archives depend on static archives.
 884     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
 885
 886     # Go through the arguments, transforming them on the way.
 887     while test $# -gt 0; do
 888       arg="$1"
 889       shift
 890
 891       # If the previous option needs an argument, assign it.
 892       if test -n "$prev"; then
 893         case "$prev" in
 894         output)
 895           compile_command="$compile_command @OUTPUT@"
 896           finalize_command="$finalize_command @OUTPUT@"
 897           ;;
 898         esac
 899
 900         case "$prev" in
 901         dlfiles|dlprefiles)
 902           if test "$preload" = no; then
 903             # Add the symbol object into the linking commands.
 904             compile_command="$compile_command @SYMFILE@"
 905             finalize_command="$finalize_command @SYMFILE@"
 906             preload=yes
 907           fi
 908           case "$arg" in
 909           *.la | *.lo) ;;  # We handle these cases below.
 910           force)
 911             if test "$dlself" = no; then
 912               dlself=needless
 913               export_dynamic=yes
 914             fi
 915             prev=
 916             continue
 917             ;;
 918           self)
 919             if test "$prev" = dlprefiles; then
 920               dlself=yes
 921             elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
 922               dlself=yes
 923             else
 924               dlself=needless
 925               export_dynamic=yes
 926             fi
 927             prev=
 928             continue
 929             ;;
 930           *)
 931             if test "$prev" = dlfiles; then
 932               dlfiles="$dlfiles $arg"
 933             else
 934               dlprefiles="$dlprefiles $arg"
 935             fi
 936             prev=
 937             ;;
 938           esac
 939           ;;
 940         expsyms)
 941           export_symbols="$arg"
 942           if test ! -f "$arg"; then
 943             $echo "$modename: symbol file \`$arg' does not exist"
 944             exit 1
 945           fi
 946           prev=
 947           continue
 948           ;;
 949         expsyms_regex)
 950           export_symbols_regex="$arg"
 951           prev=
 952           continue
 953           ;;
 954         release)
 955           release="-$arg"
 956           prev=
 957           continue
 958           ;;
 959         rpath | xrpath)
 960           # We need an absolute path.
 961           case "$arg" in
 962           [\\/]* | [A-Za-z]:[\\/]*) ;;
 963           *)
 964             $echo "$modename: only absolute run-paths are allowed" 1>&2
 965             exit 1
 966             ;;
 967           esac
 968           if test "$prev" = rpath; then
 969             case "$rpath " in
 970             *" $arg "*) ;;
 971             *) rpath="$rpath $arg" ;;
 972             esac
 973           else
 974             case "$xrpath " in
 975             *" $arg "*) ;;
 976             *) xrpath="$xrpath $arg" ;;
 977             esac
 978           fi
 979           prev=
 980           continue
 981           ;;
 982         *)
 983           eval "$prev=\"\$arg\""
 984           prev=
 985           continue
 986           ;;
 987         esac
 988       fi
 989
 990       prevarg="$arg"
 991
 992       case "$arg" in
 993       -all-static)
 994         if test -n "$link_static_flag"; then
 995           compile_command="$compile_command $link_static_flag"
 996           finalize_command="$finalize_command $link_static_flag"
 997         fi
 998         continue
 999         ;;
1000
1001       -allow-undefined)
1002         # FIXME: remove this flag sometime in the future.
1003         $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1004         continue
1005         ;;
1006
1007       -avoid-version)
1008         avoid_version=yes
1009         continue
1010         ;;
1011
1012       -dlopen)
1013         prev=dlfiles
1014         continue
1015         ;;
1016
1017       -dlpreopen)
1018         prev=dlprefiles
1019         continue
1020         ;;
1021
1022       -export-dynamic)
1023         export_dynamic=yes
1024         continue
1025         ;;
1026
1027       -export-symbols | -export-symbols-regex)
1028         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1029           $echo "$modename: not more than one -exported-symbols argument allowed"
1030           exit 1
1031         fi
1032         if test "X$arg" = "X-export-symbols"; then
1033           prev=expsyms
1034         else
1035           prev=expsyms_regex
1036         fi
1037         continue
1038         ;;
1039
1040       -L*)
1041         dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1042         # We need an absolute path.
1043         case "$dir" in
1044         [\\/]* | [A-Za-z]:[\\/]*) ;;
1045         *)
1046           absdir=`cd "$dir" && pwd`
1047           if test -z "$absdir"; then
1048             $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
1049             $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
1050             absdir="$dir"
1051           fi
1052           dir="$absdir"
1053           ;;
1054         esac
1055         case " $deplibs " in
1056         *" $arg "*) ;;
1057         *) deplibs="$deplibs $arg";;
1058         esac
1059         case " $lib_search_path " in
1060         *" $dir "*) ;;
1061         *) lib_search_path="$lib_search_path $dir";;
1062         esac
1063         case "$host" in
1064         *-*-cygwin* | *-*-mingw* | *-*-os2*)
1065           dllsearchdir=`cd "$dir" && pwd || echo "$dir"`
1066           case ":$dllsearchpath:" in
1067           ::) dllsearchpath="$dllsearchdir";;
1068           *":$dllsearchdir:"*) ;;
1069           *) dllsearchpath="$dllsearchpath:$dllsearchdir";;
1070           esac
1071           ;;
1072         esac
1073         ;;
1074
1075       -l*)
1076         if test "$arg" = "-lc"; then
1077           case "$host" in
1078           *-*-cygwin* | *-*-mingw* | *-*-os2* | *-*-beos*)
1079             # These systems don't actually have c library (as such)
1080             continue
1081             ;;
1082           esac
1083         elif test "$arg" = "-lm"; then
1084           case "$host" in
1085           *-*-cygwin* | *-*-beos*)
1086             # These systems don't actually have math library (as such)
1087             continue
1088             ;;
1089           esac
1090         fi
1091         deplibs="$deplibs $arg"
1092         ;;
1093
1094       -module)
1095         module=yes
1096         continue
1097         ;;
1098
1099       -no-undefined)
1100         allow_undefined=no
1101         continue
1102         ;;
1103
1104       -o) prev=output ;;
1105
1106       -release)
1107         prev=release
1108         continue
1109         ;;
1110
1111       -rpath)
1112         prev=rpath
1113         continue
1114         ;;
1115
1116       -R)
1117         prev=xrpath
1118         continue
1119         ;;
1120
1121       -R*)
1122         dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1123         # We need an absolute path.
1124         case "$dir" in
1125         [\\/]* | [A-Za-z]:[\\/]*) ;;
1126         *)
1127           $echo "$modename: only absolute run-paths are allowed" 1>&2
1128           exit 1
1129           ;;
1130         esac
1131         case "$xrpath " in
1132         *" $dir "*) ;;
1133         *) xrpath="$xrpath $dir" ;;
1134         esac
1135         continue
1136         ;;
1137
1138       -static)
1139         # If we have no pic_flag, then this is the same as -all-static.
1140         if test -z "$pic_flag" && test -n "$link_static_flag"; then
1141           compile_command="$compile_command $link_static_flag"
1142           finalize_command="$finalize_command $link_static_flag"
1143         fi
1144         continue
1145         ;;
1146
1147       -thread-safe)
1148         thread_safe=yes
1149         continue
1150         ;;
1151
1152       -version-info)
1153         prev=vinfo
1154         continue
1155         ;;
1156
1157       # Some other compiler flag.
1158       -* | +*)
1159         # Unknown arguments in both finalize_command and compile_command need
1160         # to be aesthetically quoted because they are evaled later.
1161         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1162         case "$arg" in
1163         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*)
1164           arg="\"$arg\""
1165           ;;
1166         esac
1167         ;;
1168
1169       *.o | *.obj | *.a | *.lib)
1170         # A standard object.
1171         objs="$objs $arg"
1172         ;;
1173
1174       *.lo)
1175         # A library object.
1176         if test "$prev" = dlfiles; then
1177           dlfiles="$dlfiles $arg"
1178           if test "$build_libtool_libs" = yes && test "$dlopen" = yes; then
1179             prev=
1180             continue
1181           else
1182             # If libtool objects are unsupported, then we need to preload.
1183             prev=dlprefiles
1184           fi
1185         fi
1186
1187         if test "$prev" = dlprefiles; then
1188           # Preload the old-style object.
1189           dlprefiles="$dlprefiles "`$echo "X$arg" | $Xsed -e "$lo2o"`
1190           prev=
1191         fi
1192         libobjs="$libobjs $arg"
1193         ;;
1194
1195       *.la)
1196         # A libtool-controlled library.
1197
1198         dlname=
1199         libdir=
1200         library_names=
1201         old_library=
1202
1203         # Check to see that this really is a libtool archive.
1204         if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
1205         else
1206           $echo "$modename: \`$arg' is not a valid libtool archive" 1>&2
1207           exit 1
1208         fi
1209
1210         # If the library was installed with an old release of libtool,
1211         # it will not redefine variable installed.
1212         installed=yes
1213
1214         # Read the .la file
1215         # If there is no directory component, then add one.
1216         case "$arg" in
1217         */* | *\\*) . $arg ;;
1218         *) . ./$arg ;;
1219         esac
1220
1221         # Get the name of the library we link against.
1222         linklib=
1223         for l in $old_library $library_names; do
1224           linklib="$l"
1225         done
1226
1227         if test -z "$linklib"; then
1228           $echo "$modename: cannot find name of link library for \`$arg'" 1>&2
1229           exit 1
1230         fi
1231
1232         # Find the relevant object directory and library name.
1233         name=`$echo "X$arg" | $Xsed -e 's%^.*/%%' -e 's/\.la$//' -e 's/^lib//'`
1234
1235         if test "X$installed" = Xyes; then
1236           dir="$libdir"
1237         else
1238           dir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1239           if test "X$dir" = "X$arg"; then
1240             dir="$objdir"
1241           else
1242             dir="$dir/$objdir"
1243           fi
1244         fi
1245
1246         if test -n "$dependency_libs"; then
1247           # Extract -R and -L from dependency_libs
1248           temp_deplibs=
1249           for deplib in $dependency_libs; do
1250             case "$deplib" in
1251             -R*) temp_xrpath=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
1252                  case " $rpath $xrpath " in
1253                  *" $temp_xrpath "*) ;;
1254                  *) xrpath="$xrpath $temp_xrpath";;
1255                  esac;;
1256             -L*) case "$compile_command $temp_deplibs " in
1257                  *" $deplib "*) ;;
1258                  *) temp_deplibs="$temp_deplibs $deplib";;
1259                  esac
1260                  temp_dir=`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1261                  case " $lib_search_path " in
1262                  *" $temp_dir "*) ;;
1263                  *) lib_search_path="$lib_search_path $temp_dir";;
1264                  esac
1265                  ;;
1266             *) temp_deplibs="$temp_deplibs $deplib";;
1267             esac
1268           done
1269           dependency_libs="$temp_deplibs"
1270         fi
1271
1272         if test -z "$libdir"; then
1273           # It is a libtool convenience library, so add in its objects.
1274           convenience="$convenience $dir/$old_library"
1275           old_convenience="$old_convenience $dir/$old_library"
1276           deplibs="$deplibs$dependency_libs"
1277           compile_command="$compile_command $dir/$old_library$dependency_libs"
1278           finalize_command="$finalize_command $dir/$old_library$dependency_libs"
1279           continue
1280         fi
1281
1282         # This library was specified with -dlopen.
1283         if test "$prev" = dlfiles; then
1284           dlfiles="$dlfiles $arg"
1285           if test -z "$dlname" || test "$dlopen" != yes || test "$build_libtool_libs" = no; then
1286             # If there is no dlname, no dlopen support or we're linking statically,
1287             # we need to preload.
1288             prev=dlprefiles
1289           else
1290             # We should not create a dependency on this library, but we
1291             # may need any libraries it requires.
1292             compile_command="$compile_command$dependency_libs"
1293             finalize_command="$finalize_command$dependency_libs"
1294             prev=
1295             continue
1296           fi
1297         fi
1298
1299         # The library was specified with -dlpreopen.
1300         if test "$prev" = dlprefiles; then
1301           # Prefer using a static library (so that no silly _DYNAMIC symbols
1302           # are required to link).
1303           if test -n "$old_library"; then
1304             dlprefiles="$dlprefiles $dir/$old_library"
1305           else
1306             dlprefiles="$dlprefiles $dir/$linklib"
1307           fi
1308           prev=
1309         fi
1310
1311         if test -n "$library_names" &&
1312            { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
1313           link_against_libtool_libs="$link_against_libtool_libs $arg"
1314           if test -n "$shlibpath_var"; then
1315             # Make sure the rpath contains only unique directories.
1316             case "$temp_rpath " in
1317             *" $dir "*) ;;
1318             *) temp_rpath="$temp_rpath $dir" ;;
1319             esac
1320           fi
1321
1322           # We need an absolute path.
1323           case "$dir" in
1324           [\\/] | [A-Za-z]:[\\/]*) absdir="$dir" ;;
1325           *)
1326             absdir=`cd "$dir" && pwd`
1327             if test -z "$absdir"; then
1328               $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
1329               $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
1330               absdir="$dir"
1331             fi
1332             ;;
1333           esac
1334
1335           # This is the magic to use -rpath.
1336           # Skip directories that are in the system default run-time
1337           # search path, unless they have been requested with -R.
1338           case " $sys_lib_dlsearch_path " in
1339           *" $absdir "*) ;;
1340           *)
1341             case "$compile_rpath " in
1342             *" $absdir "*) ;;
1343             *) compile_rpath="$compile_rpath $absdir"
1344             esac
1345             ;;
1346           esac
1347
1348           case " $sys_lib_dlsearch_path " in
1349           *" $libdir "*) ;;
1350           *)
1351             case "$finalize_rpath " in
1352             *" $libdir "*) ;;
1353             *) finalize_rpath="$finalize_rpath $libdir"
1354             esac
1355             ;;
1356           esac
1357
1358           lib_linked=yes
1359           case "$hardcode_action" in
1360           immediate | unsupported)
1361             if test "$hardcode_direct" = no; then
1362               compile_command="$compile_command $dir/$linklib"
1363               deplibs="$deplibs $dir/$linklib"
1364               case "$host" in
1365               *-*-cygwin* | *-*-mingw* | *-*-os2*)
1366                 dllsearchdir=`cd "$dir" && pwd || echo "$dir"`
1367                 if test -n "$dllsearchpath"; then
1368                   dllsearchpath="$dllsearchpath:$dllsearchdir"
1369                 else
1370                   dllsearchpath="$dllsearchdir"
1371                 fi
1372                 ;;
1373               esac
1374             elif test "$hardcode_minus_L" = no; then
1375               case "$host" in
1376               *-*-sunos*)
1377                 compile_shlibpath="$compile_shlibpath$dir:"
1378                 ;;
1379               esac
1380               case "$compile_command " in
1381               *" -L$dir "*) ;;
1382               *) compile_command="$compile_command -L$dir";;
1383               esac
1384               compile_command="$compile_command -l$name"
1385               deplibs="$deplibs -L$dir -l$name"
1386             elif test "$hardcode_shlibpath_var" = no; then
1387               case ":$compile_shlibpath:" in
1388               *":$dir:"*) ;;
1389               *) compile_shlibpath="$compile_shlibpath$dir:";;
1390               esac
1391               compile_command="$compile_command -l$name"
1392               deplibs="$deplibs -l$name"
1393             else
1394               lib_linked=no
1395             fi
1396             ;;
1397
1398           relink)
1399             if test "$hardcode_direct" = yes; then
1400               compile_command="$compile_command $absdir/$linklib"
1401               deplibs="$deplibs $absdir/$linklib"
1402             elif test "$hardcode_minus_L" = yes; then
1403               case "$compile_command " in
1404               *" -L$absdir "*) ;;
1405               *) compile_command="$compile_command -L$absdir";;
1406               esac
1407               compile_command="$compile_command -l$name"
1408               deplibs="$deplibs -L$absdir -l$name"
1409             elif test "$hardcode_shlibpath_var" = yes; then
1410               case ":$compile_shlibpath:" in
1411               *":$absdir:"*) ;;
1412               *) compile_shlibpath="$compile_shlibpath$absdir:";;
1413               esac
1414               compile_command="$compile_command -l$name"
1415               deplibs="$deplibs -l$name"
1416             else
1417               lib_linked=no
1418             fi
1419             ;;
1420
1421           *)
1422             lib_linked=no
1423             ;;
1424           esac
1425
1426           if test "$lib_linked" != yes; then
1427             $echo "$modename: configuration error: unsupported hardcode properties"
1428             exit 1
1429           fi
1430
1431           # Finalize command for both is simple: just hardcode it.
1432           if test "$hardcode_direct" = yes; then
1433             finalize_command="$finalize_command $libdir/$linklib"
1434           elif test "$hardcode_minus_L" = yes; then
1435             case "$finalize_command " in
1436             *" -L$libdir "*) ;;
1437             *) finalize_command="$finalize_command -L$libdir";;
1438             esac
1439             finalize_command="$finalize_command -l$name"
1440           elif test "$hardcode_shlibpath_var" = yes; then
1441             case ":$finalize_shlibpath:" in
1442             *":$libdir:"*) ;;
1443             *) finalize_shlibpath="$finalize_shlibpath$libdir:";;
1444             esac
1445             finalize_command="$finalize_command -l$name"
1446           else
1447             # We cannot seem to hardcode it, guess we'll fake it.
1448             case "$finalize_command " in
1449             *" -L$dir "*) ;;
1450             *) finalize_command="$finalize_command -L$libdir";;
1451             esac
1452             finalize_command="$finalize_command -l$name"
1453           fi
1454         else
1455           # Transform directly to old archives if we don't build new libraries.
1456           if test -n "$pic_flag" && test -z "$old_library"; then
1457             $echo "$modename: cannot find static library for \`$arg'" 1>&2
1458             exit 1
1459           fi
1460
1461           # Here we assume that one of hardcode_direct or hardcode_minus_L
1462           # is not unsupported.  This is valid on all known static and
1463           # shared platforms.
1464           if test "$hardcode_direct" != unsupported; then
1465             test -n "$old_library" && linklib="$old_library"
1466             compile_command="$compile_command $dir/$linklib"
1467             finalize_command="$finalize_command $dir/$linklib"
1468           else
1469             case "$compile_command " in
1470             *" -L$dir "*) ;;
1471             *) compile_command="$compile_command -L$dir";;
1472             esac
1473             compile_command="$compile_command -l$name"
1474             case "$finalize_command " in
1475             *" -L$dir "*) ;;
1476             *) finalize_command="$finalize_command -L$dir";;
1477             esac
1478             finalize_command="$finalize_command -l$name"
1479           fi
1480         fi
1481
1482         # Add in any libraries that this one depends upon.
1483         compile_command="$compile_command$dependency_libs"
1484         finalize_command="$finalize_command$dependency_libs"
1485         continue
1486         ;;
1487
1488       # Some other compiler argument.
1489       *)
1490         # Unknown arguments in both finalize_command and compile_command need
1491         # to be aesthetically quoted because they are evaled later.
1492         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1493         case "$arg" in
1494         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*)
1495           arg="\"$arg\""
1496           ;;
1497         esac
1498         ;;
1499       esac
1500
1501       # Now actually substitute the argument into the commands.
1502       if test -n "$arg"; then
1503         compile_command="$compile_command $arg"
1504         finalize_command="$finalize_command $arg"
1505       fi
1506     done
1507
1508     if test -n "$prev"; then
1509       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1510       $echo "$help" 1>&2
1511       exit 1
1512     fi
1513
1514     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1515       eval arg=\"$export_dynamic_flag_spec\"
1516       compile_command="$compile_command $arg"
1517       finalize_command="$finalize_command $arg"
1518     fi
1519
1520     oldlibs=
1521     # calculate the name of the file, without its directory
1522     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1523     libobjs_save="$libobjs"
1524
1525     case "$output" in
1526     "")
1527       $echo "$modename: you must specify an output file" 1>&2
1528       $echo "$help" 1>&2
1529       exit 1
1530       ;;
1531
1532     *.a | *.lib)
1533       if test -n "$link_against_libtool_libs"; then
1534         $echo "$modename: error: cannot link libtool libraries into archives" 1>&2
1535         exit 1
1536       fi
1537
1538       if test -n "$deplibs"; then
1539         $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
1540       fi
1541
1542       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
1543         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
1544       fi
1545
1546       if test -n "$rpath"; then
1547         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
1548       fi
1549
1550       if test -n "$xrpath"; then
1551         $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
1552       fi
1553
1554       if test -n "$vinfo"; then
1555         $echo "$modename: warning: \`-version-info' is ignored for archives" 1>&2
1556       fi
1557
1558       if test -n "$release"; then
1559         $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
1560       fi
1561
1562       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1563         $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
1564       fi
1565
1566       # Now set the variables for building old libraries.
1567       build_libtool_libs=no
1568       oldlibs="$output"
1569       ;;
1570
1571     *.la)
1572       # Make sure we only generate libraries of the form `libNAME.la'.
1573       case "$outputname" in
1574       lib*)
1575         name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
1576         eval libname=\"$libname_spec\"
1577         ;;
1578       *)
1579         if test "$module" = no; then
1580           $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
1581           $echo "$help" 1>&2
1582           exit 1
1583         fi
1584         if test "$need_lib_prefix" != no; then
1585           # Add the "lib" prefix for modules if required
1586           name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
1587           eval libname=\"$libname_spec\"
1588         else
1589           libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
1590         fi
1591         ;;
1592       esac
1593
1594       output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1595       if test "X$output_objdir" = "X$output"; then
1596         output_objdir="$objdir"
1597       else
1598         output_objdir="$output_objdir/$objdir"
1599       fi
1600
1601       if test -n "$objs"; then
1602         $echo "$modename: cannot build libtool library \`$output' from non-libtool objects:$objs" 2>&1
1603         exit 1
1604       fi
1605
1606       # How the heck are we supposed to write a wrapper for a shared library?
1607       if test -n "$link_against_libtool_libs"; then
1608          $echo "$modename: error: cannot link shared libraries into libtool libraries" 1>&2
1609          exit 1
1610       fi
1611
1612       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
1613         $echo "$modename: warning: \`-dlopen' is ignored for libtool libraries" 1>&2
1614       fi
1615
1616       set dummy $rpath
1617       if test $# -gt 2; then
1618         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
1619       fi
1620       install_libdir="$2"
1621
1622       oldlibs=
1623       if test -z "$rpath"; then
1624         if test "$build_libtool_libs" = yes; then
1625           # Building a libtool convenience library.
1626           libext=al
1627           oldlibs="$output_objdir/$libname.$libext $oldlibs"
1628           build_libtool_libs=convenience
1629           build_old_libs=yes
1630         fi
1631         dependency_libs="$deplibs"
1632
1633         if test -n "$vinfo"; then
1634           $echo "$modename: warning: \`-version-info' is ignored for convenience libraries" 1>&2
1635         fi
1636
1637         if test -n "$release"; then
1638           $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
1639         fi
1640       else
1641
1642         # Parse the version information argument.
1643         IFS="${IFS=     }"; save_ifs="$IFS"; IFS=':'
1644         set dummy $vinfo 0 0 0
1645         IFS="$save_ifs"
1646
1647         if test -n "$8"; then
1648           $echo "$modename: too many parameters to \`-version-info'" 1>&2
1649           $echo "$help" 1>&2
1650           exit 1
1651         fi
1652
1653         current="$2"
1654         revision="$3"
1655         age="$4"
1656
1657         # Check that each of the things are valid numbers.
1658         case "$current" in
1659         0 | [1-9] | [1-9][0-9]*) ;;
1660         *)
1661           $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
1662           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
1663           exit 1
1664           ;;
1665         esac
1666
1667         case "$revision" in
1668         0 | [1-9] | [1-9][0-9]*) ;;
1669         *)
1670           $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
1671           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
1672           exit 1
1673           ;;
1674         esac
1675
1676         case "$age" in
1677         0 | [1-9] | [1-9][0-9]*) ;;
1678         *)
1679           $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
1680           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
1681           exit 1
1682           ;;
1683         esac
1684
1685         if test $age -gt $current; then
1686           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
1687           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
1688           exit 1
1689         fi
1690
1691         # Calculate the version variables.
1692         major=
1693         versuffix=
1694         verstring=
1695         case "$version_type" in
1696         none) ;;
1697
1698         irix)
1699           major=`expr $current - $age + 1`
1700           versuffix="$major.$revision"
1701           verstring="sgi$major.$revision"
1702
1703           # Add in all the interfaces that we are compatible with.
1704           loop=$revision
1705           while test $loop != 0; do
1706             iface=`expr $revision - $loop`
1707             loop=`expr $loop - 1`
1708             verstring="sgi$major.$iface:$verstring"
1709           done
1710           ;;
1711
1712         linux)
1713           major=.`expr $current - $age`
1714           versuffix="$major.$age.$revision"
1715           ;;
1716
1717         osf)
1718           major=`expr $current - $age`
1719           versuffix=".$current.$age.$revision"
1720           verstring="$current.$age.$revision"
1721
1722           # Add in all the interfaces that we are compatible with.
1723           loop=$age
1724           while test $loop != 0; do
1725             iface=`expr $current - $loop`
1726             loop=`expr $loop - 1`
1727             verstring="$verstring:${iface}.0"
1728           done
1729
1730           # Make executables depend on our current version.
1731           verstring="$verstring:${current}.0"
1732           ;;
1733
1734         sunos)
1735           major=".$current"
1736           versuffix=".$current.$revision"
1737           ;;
1738
1739         freebsd-aout)
1740           major=".$current"
1741           versuffix=".$current.$revision";
1742           ;;
1743
1744         freebsd-elf)
1745           major=".$current"
1746           versuffix=".$current";
1747           ;;
1748
1749         windows)
1750           # Like Linux, but with '-' rather than '.', since we only
1751           # want one extension on Windows 95.
1752           major=`expr $current - $age`
1753           versuffix="-$major-$age-$revision"
1754           ;;
1755
1756         *)
1757           $echo "$modename: unknown library version type \`$version_type'" 1>&2
1758           echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
1759           exit 1
1760           ;;
1761         esac
1762
1763         # Clear the version info if we defaulted, and they specified a release.
1764         if test -z "$vinfo" && test -n "$release"; then
1765           major=
1766           verstring="0.0"
1767           if test "$need_version" = no; then
1768             versuffix=
1769           else
1770             versuffix=".0.0"
1771           fi
1772         fi
1773
1774         # Remove version info from name if versioning should be avoided
1775         if test "$avoid_version" = yes && test "$need_version" = no; then
1776           major=
1777           versuffix=
1778           verstring=""
1779         fi
1780
1781         # Check to see if the archive will have undefined symbols.
1782         if test "$allow_undefined" = yes; then
1783           if test "$allow_undefined_flag" = unsupported; then
1784             $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
1785             build_libtool_libs=no
1786             build_old_libs=yes
1787           fi
1788         else
1789           # Don't allow undefined symbols.
1790           allow_undefined_flag="$no_undefined_flag"
1791         fi
1792
1793         dependency_libs="$deplibs"
1794         case "$host" in
1795         *-*-cygwin* | *-*-mingw* | *-*-os2* | *-*-beos*)
1796           # these systems don't actually have a c library (as such)!
1797           ;;
1798         *)
1799           # Add libc to deplibs on all other systems.
1800           deplibs="$deplibs -lc"
1801           ;;
1802         esac
1803       fi
1804
1805       # Create the output directory, or remove our outputs if we need to.
1806       if test -d $output_objdir; then
1807         $show "${rm}r $output_objdir/$outputname $output_objdir/$libname.* $output_objdir/${libname}${release}.*"
1808         $run ${rm}r $output_objdir/$outputname $output_objdir/$libname.* $output_objdir/${libname}${release}.*
1809       else
1810         $show "$mkdir $output_objdir"
1811         $run $mkdir $output_objdir
1812         status=$?
1813         if test $status -ne 0 && test ! -d $output_objdir; then
1814           exit $status
1815         fi
1816       fi
1817
1818       # Now set the variables for building old libraries.
1819       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
1820         oldlibs="$oldlibs $output_objdir/$libname.$libext"
1821
1822         # Transform .lo files to .o files.
1823         oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
1824       fi
1825
1826       if test "$build_libtool_libs" = yes; then
1827         # Transform deplibs into only deplibs that can be linked in shared.
1828         name_save=$name
1829         libname_save=$libname
1830         release_save=$release
1831         versuffix_save=$versuffix
1832         major_save=$major
1833         # I'm not sure if I'm treating the release correctly.  I think
1834         # release should show up in the -l (ie -lgmp5) so we don't want to
1835         # add it in twice.  Is that correct?
1836         release=""
1837         versuffix=""
1838         major=""
1839         newdeplibs=
1840         droppeddeps=no
1841         case "$deplibs_check_method" in
1842         pass_all)
1843           # Don't check for shared/static.  Everything works.
1844           # This might be a little naive.  We might want to check
1845           # whether the library exists or not.  But this is on
1846           # osf3 & osf4 and I'm not really sure... Just
1847           # implementing what was already the behaviour.
1848           newdeplibs=$deplibs
1849           ;;
1850         test_compile)
1851           # This code stresses the "libraries are programs" paradigm to its
1852           # limits. Maybe even breaks it.  We compile a program, linking it
1853           # against the deplibs as a proxy for the library.  Then we can check
1854           # whether they linked in statically or dynamically with ldd.
1855           $rm conftest.c
1856           cat > conftest.c <<EOF
1857           int main() { return 0; }
1858 EOF
1859           $rm conftest
1860           $CC -o conftest conftest.c $deplibs
1861           if test $? -eq 0 ; then
1862             ldd_output=`ldd conftest`
1863             for i in $deplibs; do
1864               name="`expr $i : '-l\(.*\)'`"
1865               # If $name is empty we are operating on a -L argument.
1866               if test "$name" != "" ; then
1867                 libname=`eval \\$echo \"$libname_spec\"`
1868                 deplib_matches=`eval \\$echo \"$library_names_spec\"`
1869                 set dummy $deplib_matches
1870                 deplib_match=$2
1871                 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
1872                   newdeplibs="$newdeplibs $i"
1873                 else
1874                   droppeddeps=yes
1875                   echo
1876                   echo "*** Warning: This library needs some functionality provided by $i."
1877                   echo "*** I have the capability to make that library automatically link in when"
1878                   echo "*** you link to this library.  But I can only do this if you have a"
1879                   echo "*** shared version of the library, which you do not appear to have."
1880                 fi
1881               else
1882                 newdeplibs="$newdeplibs $i"
1883               fi
1884             done
1885           else
1886             # Error occured in the first compile.  Let's try to salvage the situation:
1887             # Compile a seperate program for each library.
1888             for i in $deplibs; do
1889               name="`expr $i : '-l\(.*\)'`"
1890              # If $name is empty we are operating on a -L argument.
1891               if test "$name" != "" ; then
1892                 $rm conftest
1893                 $CC -o conftest conftest.c $i
1894                 # Did it work?
1895                 if test $? -eq 0 ; then
1896                   ldd_output=`ldd conftest`
1897                   libname=`eval \\$echo \"$libname_spec\"`
1898                   deplib_matches=`eval \\$echo \"$library_names_spec\"`
1899                   set dummy $deplib_matches
1900                   deplib_match=$2
1901                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
1902                     newdeplibs="$newdeplibs $i"
1903                   else
1904                     droppeddeps=yes
1905                     echo
1906                     echo "*** Warning: This library needs some functionality provided by $i."
1907                     echo "*** I have the capability to make that library automatically link in when"
1908                     echo "*** you link to this library.  But I can only do this if you have a"
1909                     echo "*** shared version of the library, which you do not appear to have."
1910                   fi
1911                 else
1912                   droppeddeps=yes
1913                   echo
1914                   echo "*** Warning!  Library $i is needed by this library but I was not able to"
1915                   echo "***  make it link in!  You will probably need to install it or some"
1916                   echo "*** library that it depends on before this library will be fully"
1917                   echo "*** functional.  Installing it before continuing would be even better."
1918                 fi
1919               else
1920                 newdeplibs="$newdeplibs $i"
1921               fi
1922             done
1923           fi
1924           ;;
1925         file_magic*)
1926           set dummy $deplibs_check_method
1927           file_magic_regex="`expr \"$deplibs_check_method\" : \"$2 \(.*\)\"`"
1928           for a_deplib in $deplibs; do
1929             name="`expr $a_deplib : '-l\(.*\)'`"
1930             # If $name is empty we are operating on a -L argument.
1931             if test "$name" != "" ; then
1932               libname=`eval \\$echo \"$libname_spec\"`
1933               for i in $lib_search_path; do
1934                     potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
1935                     for potent_lib in $potential_libs; do
1936                       # Follow soft links.
1937                       if ls -lLd "$potent_lib" 2>/dev/null \
1938                          | grep " -> " >/dev/null; then
1939                         continue
1940                       fi
1941                       # The statement above tries to avoid entering an
1942                       # endless loop below, in case of cyclic links.
1943                       # We might still enter an endless loop, since a link
1944                       # loop can be closed while we follow links,
1945                       # but so what?
1946                       potlib="$potent_lib"
1947                       while test -h "$potlib" 2>/dev/null; do
1948                         potliblink=`ls -ld $potlib | sed 's/.* -> //'`
1949                         case "$potliblink" in
1950                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
1951                         *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
1952                         esac
1953                       done
1954                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
1955                          | sed 10q \
1956                          | egrep "$file_magic_regex" > /dev/null; then
1957                         newdeplibs="$newdeplibs $a_deplib"
1958                         a_deplib=""
1959                         break 2
1960                       fi
1961                     done
1962               done
1963               if test -n "$a_deplib" ; then
1964                 droppeddeps=yes
1965                 echo
1966                 echo "*** Warning: This library needs some functionality provided by $a_deplib."
1967                 echo "*** I have the capability to make that library automatically link in when"
1968                 echo "*** you link to this library.  But I can only do this if you have a"
1969                 echo "*** shared version of the library, which you do not appear to have."
1970               fi
1971             else
1972               # Add a -L argument.
1973               newdeplibs="$newdeplibs $a_deplib"
1974             fi
1975           done # Gone through all deplibs.
1976           ;;
1977         none | unknown | *)
1978           newdeplibs=""
1979           if $echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
1980                -e 's/ -[LR][^ ]*//g' -e 's/[    ]//g' |
1981              grep . >/dev/null; then
1982             echo
1983             if test "X$deplibs_check_method" = "Xnone"; then
1984               echo "*** Warning: inter-library dependencies are not supported in this platform."
1985             else
1986               echo "*** Warning: inter-library dependencies are not known to be supported."
1987             fi
1988             echo "*** All declared inter-library dependencies are being dropped."
1989             droppeddeps=yes
1990           fi
1991           ;;
1992         esac
1993         versuffix=$versuffix_save
1994         major=$major_save
1995         release=$release_save
1996         libname=$libname_save
1997         name=$name_save
1998
1999         if test "$droppeddeps" = yes; then
2000           if test "$module" = yes; then
2001             echo
2002             echo "*** Warning: libtool could not satisfy all declared inter-library"
2003             echo "*** dependencies of module $libname.  Therefore, libtool will create"
2004             echo "*** a static module, that should work as long as the dlopening"
2005             echo "*** application is linked with the -dlopen flag."
2006             if test -z "$global_symbol_pipe"; then
2007               echo
2008               echo "*** However, this would only work if libtool was able to extract symbol"
2009               echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2010               echo "*** not find such a program.  So, this module is probably useless."
2011               echo "*** \`nm' from GNU binutils and a full rebuild may help."
2012             fi
2013             if test "$build_old_libs" = no; then
2014               oldlibs="$output_objdir/$libname.$libext"
2015               build_libtool_libs=module
2016               build_old_libs=yes
2017             else
2018               build_libtool_libs=no
2019             fi
2020           else
2021             echo "*** The inter-library dependencies that have been dropped here will be"
2022             echo "*** automatically added whenever a program is linked with this library"
2023             echo "*** or is declared to -dlopen it."
2024           fi
2025         fi
2026         # Done checking deplibs!
2027         deplibs=$newdeplibs
2028       fi
2029
2030       # All the library-specific variables (install_libdir is set above).
2031       library_names=
2032       old_library=
2033       dlname=
2034
2035       # Test again, we may have decided not to build it any more
2036       if test "$build_libtool_libs" = yes; then
2037         # Get the real and link names of the library.
2038         eval library_names=\"$library_names_spec\"
2039         set dummy $library_names
2040         realname="$2"
2041         shift; shift
2042
2043         if test -n "$soname_spec"; then
2044           eval soname=\"$soname_spec\"
2045         else
2046           soname="$realname"
2047         fi
2048
2049         lib="$output_objdir/$realname"
2050         for link
2051         do
2052           linknames="$linknames $link"
2053         done
2054
2055         # Ensure that we have .o objects for linkers which dislike .lo
2056         # (e.g. aix) in case we are running --disable-static
2057         for obj in $libobjs; do
2058           xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
2059           if test "X$xdir" = "X$obj"; then
2060             xdir="."
2061           else
2062             xdir="$xdir"
2063           fi
2064           baseobj=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
2065           oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
2066           if test ! -f $xdir/$oldobj; then
2067             $show "(cd $xdir && ${LN_S} $baseobj $oldobj)"
2068             $run eval '(cd $xdir && ${LN_S} $baseobj $oldobj)' || exit $?
2069           fi
2070         done
2071
2072         # Use standard objects if they are pic
2073         test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2074
2075         # Prepare the list of exported symbols
2076         if test -z "$export_symbols"; then
2077           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
2078             $show "generating symbol list for \`$libname.la'"
2079             export_symbols="$output_objdir/$libname.exp"
2080             $run $rm $export_symbols
2081             eval cmds=\"$export_symbols_cmds\"
2082             IFS="${IFS=         }"; save_ifs="$IFS"; IFS='~'
2083             for cmd in $cmds; do
2084               IFS="$save_ifs"
2085               $show "$cmd"
2086               $run eval "$cmd" || exit $?
2087             done
2088             IFS="$save_ifs"
2089             if test -n "$export_symbols_regex"; then
2090               $show "egrep -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
2091               $run eval 'egrep -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
2092               $show "$mv \"${export_symbols}T\" \"$export_symbols\""
2093               $run eval '$mv "${export_symbols}T" "$export_symbols"'
2094             fi
2095           fi
2096         fi
2097
2098         if test -n "$export_symbols" && test -n "$include_expsyms"; then
2099           $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
2100         fi
2101
2102         if test -n "$convenience"; then
2103           if test -n "$whole_archive_flag_spec"; then
2104             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
2105           else
2106             gentop="$output_objdir/${outputname}x"
2107             $show "${rm}r $gentop"
2108             $run ${rm}r "$gentop"
2109             $show "mkdir $gentop"
2110             $run mkdir "$gentop"
2111             status=$?
2112             if test $status -ne 0 && test ! -d "$gentop"; then
2113               exit $status
2114             fi
2115             generated="$generated $gentop"
2116
2117             for xlib in $convenience; do
2118               # Extract the objects.
2119               case "$xlib" in
2120               [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
2121               *) xabs=`pwd`"/$xlib" ;;
2122               esac
2123               xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
2124               xdir="$gentop/$xlib"
2125
2126               $show "${rm}r $xdir"
2127               $run ${rm}r "$xdir"
2128               $show "mkdir $xdir"
2129               $run mkdir "$xdir"
2130               status=$?
2131               if test $status -ne 0 && test ! -d "$xdir"; then
2132                 exit $status
2133               fi
2134               $show "(cd $xdir && $AR x $xabs)"
2135               $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
2136
2137               libobjs="$libobjs "`find $xdir -name \*.o -print -o -name \*.lo -print | $NL2SP`
2138             done
2139           fi
2140         fi
2141
2142         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
2143           eval flag=\"$thread_safe_flag_spec\"
2144           linkopts="$linkopts $flag"
2145         fi
2146
2147         # Do each of the archive commands.
2148         if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
2149           eval cmds=\"$archive_expsym_cmds\"
2150         else
2151           eval cmds=\"$archive_cmds\"
2152         fi
2153         IFS="${IFS=     }"; save_ifs="$IFS"; IFS='~'
2154         for cmd in $cmds; do
2155           IFS="$save_ifs"
2156           $show "$cmd"
2157           $run eval "$cmd" || exit $?
2158         done
2159         IFS="$save_ifs"
2160
2161         # Create links to the real library.
2162         for linkname in $linknames; do
2163           if test "$realname" != "$linkname"; then
2164             $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
2165             $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
2166           fi
2167         done
2168
2169         # If -module or -export-dynamic was specified, set the dlname.
2170         if test "$module" = yes || test "$export_dynamic" = yes; then
2171           # On all known operating systems, these are identical.
2172           dlname="$soname"
2173         fi
2174       fi
2175       ;;
2176
2177     *.lo | *.o | *.obj)
2178       if test -n "$link_against_libtool_libs"; then
2179         $echo "$modename: error: cannot link libtool libraries into objects" 1>&2
2180         exit 1
2181       fi
2182
2183       if test -n "$deplibs"; then
2184         $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
2185       fi
2186
2187       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2188         $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
2189       fi
2190
2191       if test -n "$rpath"; then
2192         $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
2193       fi
2194
2195       if test -n "$xrpath"; then
2196         $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
2197       fi
2198
2199       if test -n "$vinfo"; then
2200         $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
2201       fi
2202
2203       if test -n "$release"; then
2204         $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
2205       fi
2206
2207       case "$output" in
2208       *.lo)
2209         if test -n "$objs"; then
2210           $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
2211           exit 1
2212         fi
2213         libobj="$output"
2214         obj=`$echo "X$output" | $Xsed -e "$lo2o"`
2215         ;;
2216       *)
2217         libobj=
2218         obj="$output"
2219         ;;
2220       esac
2221
2222       # Delete the old objects.
2223       $run $rm $obj $libobj
2224
2225       # Objects from convenience libraries.  This assumes
2226       # single-version convenience libraries.  Whenever we create
2227       # different ones for PIC/non-PIC, this we'll have to duplicate
2228       # the extraction.
2229       reload_conv_objs=
2230       gentop=
2231       # reload_cmds runs $LD directly, so let us get rid of
2232       # -Wl from whole_archive_flag_spec
2233       wl=
2234
2235       if test -n "$convenience"; then
2236         if test -n "$whole_archive_flag_spec"; then
2237           eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
2238         else
2239           gentop="$output_objdir/${obj}x"
2240           $show "${rm}r $gentop"
2241           $run ${rm}r "$gentop"
2242           $show "mkdir $gentop"
2243           $run mkdir "$gentop"
2244           status=$?
2245           if test $status -ne 0 && test ! -d "$gentop"; then
2246             exit $status
2247           fi
2248           generated="$generated $gentop"
2249
2250           for xlib in $convenience; do
2251             # Extract the objects.
2252             case "$xlib" in
2253             [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
2254             *) xabs=`pwd`"/$xlib" ;;
2255             esac
2256             xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
2257             xdir="$gentop/$xlib"
2258
2259             $show "${rm}r $xdir"
2260             $run ${rm}r "$xdir"
2261             $show "mkdir $xdir"
2262             $run mkdir "$xdir"
2263             status=$?
2264             if test $status -ne 0 && test ! -d "$xdir"; then
2265               exit $status
2266             fi
2267             $show "(cd $xdir && $AR x $xabs)"
2268             $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
2269
2270             reload_conv_objs="$reload_objs "`find $xdir -name \*.o -print -o -name \*.lo -print | $NL2SP`
2271           done
2272         fi
2273       fi
2274
2275       # Create the old-style object.
2276       reload_objs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs"
2277
2278       output="$obj"
2279       eval cmds=\"$reload_cmds\"
2280       IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
2281       for cmd in $cmds; do
2282         IFS="$save_ifs"
2283         $show "$cmd"
2284         $run eval "$cmd" || exit $?
2285       done
2286       IFS="$save_ifs"
2287
2288       # Exit if we aren't doing a library object file.
2289       if test -z "$libobj"; then
2290         if test -n "$gentop"; then
2291           $show "${rm}r $gentop"
2292           $run ${rm}r $gentop
2293         fi
2294
2295         exit 0
2296       fi
2297
2298       if test "$build_libtool_libs" != yes; then
2299         if test -n "$gentop"; then
2300           $show "${rm}r $gentop"
2301           $run ${rm}r $gentop
2302         fi
2303
2304         # Create an invalid libtool object if no PIC, so that we don't
2305         # accidentally link it into a program.
2306         $show "echo timestamp > $libobj"
2307         $run eval "echo timestamp > $libobj" || exit $?
2308         exit 0
2309       fi
2310
2311       if test -n "$pic_flag"; then
2312         # Only do commands if we really have different PIC objects.
2313         reload_objs="$libobjs $reload_conv_objs"
2314         output="$libobj"
2315         eval cmds=\"$reload_cmds\"
2316         IFS="${IFS=     }"; save_ifs="$IFS"; IFS='~'
2317         for cmd in $cmds; do
2318           IFS="$save_ifs"
2319           $show "$cmd"
2320           $run eval "$cmd" || exit $?
2321         done
2322         IFS="$save_ifs"
2323       else
2324         # Just create a symlink.
2325         $show $rm $libobj
2326         $run $rm $libobj
2327         xdir=`$echo "X$libobj" | $Xsed -e 's%/[^/]*$%%'`
2328         if test "X$xdir" = "X$libobj"; then
2329           xdir="."
2330         else
2331           xdir="$xdir"
2332         fi
2333         baseobj=`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`
2334         oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
2335         $show "(cd $xdir && $LN_S $oldobj $baseobj)"
2336         $run eval '(cd $xdir && $LN_S $oldobj $baseobj)' || exit $?
2337       fi
2338
2339       if test -n "$gentop"; then
2340         $show "${rm}r $gentop"
2341         $run ${rm}r $gentop
2342       fi
2343
2344       exit 0
2345       ;;
2346
2347     # Anything else should be a program.
2348     *)
2349       if test -n "$vinfo"; then
2350         $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
2351       fi
2352
2353       if test -n "$release"; then
2354         $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
2355       fi
2356
2357       if test "$preload" = yes; then
2358         if test "$dlopen" = unknown && test "$dlopen_self" = unknown &&
2359            test "$dlopen_self_static" = unknown; then
2360           $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
2361         fi
2362       fi
2363
2364       if test -n "$rpath$xrpath"; then
2365         # If the user specified any rpath flags, then add them.
2366         for libdir in $rpath $xrpath; do
2367           # This is the magic to use -rpath.
2368           case "$compile_rpath " in
2369           *" $libdir "*) ;;
2370           *) compile_rpath="$compile_rpath $libdir" ;;
2371           esac
2372           case "$finalize_rpath " in
2373           *" $libdir "*) ;;
2374           *) finalize_rpath="$finalize_rpath $libdir" ;;
2375           esac
2376         done
2377       fi
2378
2379       # Now hardcode the library paths
2380       rpath=
2381       hardcode_libdirs=
2382       for libdir in $compile_rpath $finalize_rpath; do
2383         if test -n "$hardcode_libdir_flag_spec"; then
2384           if test -n "$hardcode_libdir_separator"; then
2385             if test -z "$hardcode_libdirs"; then
2386               hardcode_libdirs="$libdir"
2387             else
2388               # Just accumulate the unique libdirs.
2389               case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in
2390               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
2391                 ;;
2392               *)
2393                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
2394                 ;;
2395               esac
2396             fi
2397           else
2398             eval flag=\"$hardcode_libdir_flag_spec\"
2399             rpath="$rpath $flag"
2400           fi
2401         elif test -n "$runpath_var"; then
2402           case "$perm_rpath " in
2403           *" $libdir "*) ;;
2404           *) perm_rpath="$perm_rpath $libdir" ;;
2405           esac
2406         fi
2407       done
2408       # Substitute the hardcoded libdirs into the rpath.
2409       if test -n "$hardcode_libdir_separator" &&
2410          test -n "$hardcode_libdirs"; then
2411         libdir="$hardcode_libdirs"
2412         eval rpath=\" $hardcode_libdir_flag_spec\"
2413       fi
2414       compile_rpath="$rpath"
2415
2416       rpath=
2417       hardcode_libdirs=
2418       for libdir in $finalize_rpath; do
2419         if test -n "$hardcode_libdir_flag_spec"; then
2420           if test -n "$hardcode_libdir_separator"; then
2421             if test -z "$hardcode_libdirs"; then
2422               hardcode_libdirs="$libdir"
2423             else
2424               # Just accumulate the unique libdirs.
2425               case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in
2426               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
2427                 ;;
2428               *)
2429                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
2430                 ;;
2431               esac
2432             fi
2433           else
2434             eval flag=\"$hardcode_libdir_flag_spec\"
2435             rpath="$rpath $flag"
2436           fi
2437         elif test -n "$runpath_var"; then
2438           case "$finalize_perm_rpath " in
2439           *" $libdir "*) ;;
2440           *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
2441           esac
2442         fi
2443       done
2444       # Substitute the hardcoded libdirs into the rpath.
2445       if test -n "$hardcode_libdir_separator" &&
2446          test -n "$hardcode_libdirs"; then
2447         libdir="$hardcode_libdirs"
2448         eval rpath=\" $hardcode_libdir_flag_spec\"
2449       fi
2450       finalize_rpath="$rpath"
2451
2452       output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
2453       if test "X$output_objdir" = "X$output"; then
2454         output_objdir="$objdir"
2455       else
2456         output_objdir="$output_objdir/$objdir"
2457       fi
2458
2459       # Create the binary in the object directory, then wrap it.
2460       if test ! -d $output_objdir; then
2461         $show "$mkdir $output_objdir"
2462         $run $mkdir $output_objdir
2463         status=$?
2464         if test $status -ne 0 && test ! -d $output_objdir; then
2465           exit $status
2466         fi
2467       fi
2468
2469       if test -n "$libobjs" && test "$build_old_libs" = yes; then
2470         # Transform all the library objects into standard objects.
2471         compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2472         finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2473       fi
2474
2475       dlsyms=
2476       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2477         if test -n "$NM" && test -n "$global_symbol_pipe"; then
2478           dlsyms="${outputname}S.c"
2479         else
2480           $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
2481         fi
2482       fi
2483
2484       if test -n "$dlsyms"; then
2485         case "$dlsyms" in
2486         "") ;;
2487         *.c)
2488           # Discover the nlist of each of the dlfiles.
2489           nlist="$output_objdir/${outputname}.nm"
2490
2491           $show "$rm $nlist ${nlist}S ${nlist}T"
2492           $run $rm "$nlist" "${nlist}S" "${nlist}T"
2493
2494           # Parse the name list into a source file.
2495           $show "creating $output_objdir/$dlsyms"
2496
2497           test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
2498 /* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
2499 /* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
2500
2501 #ifdef __cplusplus
2502 extern \"C\" {
2503 #endif
2504
2505 /* Prevent the only kind of declaration conflicts we can make. */
2506 #define lt_preloaded_symbols some_other_symbol
2507
2508 /* External symbol declarations for the compiler. */\
2509 "
2510
2511           if test "$dlself" = yes; then
2512             $show "generating symbol list for \`$output'"
2513
2514             test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
2515
2516             # Add our own program objects to the symbol list.
2517             progfiles=`$echo "X$objs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2518             for arg in $progfiles; do
2519               $show "extracting global C symbols from \`$arg'"
2520               $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
2521             done
2522
2523             if test -n "$exclude_expsyms"; then
2524               $run eval 'egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
2525               $run eval '$mv "$nlist"T "$nlist"'
2526             fi
2527
2528             if test -n "$export_symbols_regex"; then
2529               $run eval 'egrep -e "$export_symbols_regex" "$nlist" > "$nlist"T'
2530               $run eval '$mv "$nlist"T "$nlist"'
2531             fi
2532
2533             # Prepare the list of exported symbols
2534             if test -z "$export_symbols"; then
2535               export_symbols="$output_objdir/$output.exp"
2536               $run $rm $export_symbols
2537               $run eval "sed -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
2538             else
2539               $run eval "sed -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
2540               $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
2541               $run eval 'mv "$nlist"T "$nlist"'
2542             fi
2543           fi
2544
2545           for arg in $dlprefiles; do
2546             $show "extracting global C symbols from \`$arg'"
2547             name=`echo "$arg" | sed -e 's%^.*/%%'`
2548             $run eval 'echo ": $name " >> "$nlist"'
2549             $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
2550           done
2551
2552           if test -z "$run"; then
2553             # Make sure we have at least an empty file.
2554             test -f "$nlist" || : > "$nlist"
2555
2556             if test -n "$exclude_expsyms"; then
2557               egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2558               $mv "$nlist"T "$nlist"
2559             fi
2560
2561             # Try sorting and uniquifying the output.
2562             if grep -v "^: " < "$nlist" | sort +2 | uniq > "$nlist"S; then
2563               :
2564             else
2565               grep -v "^: " < "$nlist" > "$nlist"S
2566             fi
2567
2568             if test -f "$nlist"S; then
2569               eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
2570             else
2571               echo '/* NONE */' >> "$output_objdir/$dlsyms"
2572             fi
2573
2574             $echo >> "$output_objdir/$dlsyms" "\
2575
2576 #undef lt_preloaded_symbols
2577
2578 #if defined (__STDC__) && __STDC__
2579 # define lt_ptr_t void *
2580 #else
2581 # define lt_ptr_t char *
2582 # define const
2583 #endif
2584
2585 /* The mapping between symbol names and symbols. */
2586 const struct {
2587   const char *name;
2588   lt_ptr_t address;
2589 }
2590 lt_preloaded_symbols[] =
2591 {\
2592 "
2593
2594             sed -n -e 's/^: \([^ ]*\) $/  {\"\1\", (lt_ptr_t) 0},/p' \
2595                 -e 's/^. \([^ ]*\) \([^ ]*\)$/  {"\2", (lt_ptr_t) \&\2},/p' \
2596                   < "$nlist" >> "$output_objdir/$dlsyms"
2597
2598             $echo >> "$output_objdir/$dlsyms" "\
2599   {0, (lt_ptr_t) 0}
2600 };
2601
2602 /* This works around a problem in FreeBSD linker */
2603 #ifdef FREEBSD_WORKAROUND
2604 static const void *lt_preloaded_setup() {
2605   return lt_preloaded_symbols;
2606 }
2607 #endif
2608
2609 #ifdef __cplusplus
2610 }
2611 #endif\
2612 "
2613           fi
2614
2615           pic_flag_for_symtable=
2616           case "$host" in
2617           # compiling the symbol table file with pic_flag works around
2618           # a FreeBSD bug that causes programs to crash when -lm is
2619           # linked before any other PIC object.  But we must not use
2620           # pic_flag when linking with -static.  The problem exists in
2621           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2622           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)\r
2623             case "$compile_command " in
2624             *" -static "*) ;;
2625             *) pic_flag_for_symtable=" $pic_flag -DPIC -DFREEBSD_WORKAROUND";;
2626             esac;;
2627           *-*-hpux*)
2628             case "$compile_command " in
2629             *" -static "*) ;;
2630             *) pic_flag_for_symtable=" $pic_flag -DPIC";;
2631             esac
2632           esac
2633
2634           # Now compile the dynamic symbol file.
2635           $show "(cd $output_objdir && $CC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
2636           $run eval '(cd $output_objdir && $CC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
2637
2638           # Clean up the generated files.
2639           $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
2640           $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
2641
2642           # Transform the symbol file into the correct name.
2643           compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
2644           finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
2645           ;;
2646         *)
2647           $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
2648           exit 1
2649           ;;
2650         esac
2651       else
2652         # We keep going just in case the user didn't refer to
2653         # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
2654         # really was required.
2655
2656         # Nullify the symbol file.
2657         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
2658         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
2659       fi
2660
2661       if test -z "$link_against_libtool_libs" || test "$build_libtool_libs" != yes; then
2662         # Replace the output file specification.
2663         compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
2664         link_command="$compile_command$compile_rpath"
2665
2666         # We have no uninstalled library dependencies, so finalize right now.
2667         $show "$link_command"
2668         $run eval "$link_command"
2669         status=$?
2670
2671         # Delete the generated files.
2672         if test -n "$dlsyms"; then
2673           $show "$rm $output_objdir/${outputname}S.${objext}"
2674           $run $rm "$output_objdir/${outputname}S.${objext}"
2675         fi
2676
2677         exit $status
2678       fi
2679
2680       if test -n "$shlibpath_var"; then
2681         # We should set the shlibpath_var
2682         rpath=
2683         for dir in $temp_rpath; do
2684           case "$dir" in
2685           [\\/]* | [A-Za-z]:[\\/]*)
2686             # Absolute path.
2687             rpath="$rpath$dir:"
2688             ;;
2689           *)
2690             # Relative path: add a thisdir entry.
2691             rpath="$rpath\$thisdir/$dir:"
2692             ;;
2693           esac
2694         done
2695         temp_rpath="$rpath"
2696       fi
2697
2698       if test -n "$compile_shlibpath$finalize_shlibpath"; then
2699         compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
2700       fi
2701       if test -n "$finalize_shlibpath"; then
2702         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
2703       fi
2704
2705       compile_var=
2706       finalize_var=
2707       if test -n "$runpath_var"; then
2708         if test -n "$perm_rpath"; then
2709           # We should set the runpath_var.
2710           rpath=
2711           for dir in $perm_rpath; do
2712             rpath="$rpath$dir:"
2713           done
2714           compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
2715         fi
2716         if test -n "$finalize_perm_rpath"; then
2717           # We should set the runpath_var.
2718           rpath=
2719           for dir in $finalize_perm_rpath; do
2720             rpath="$rpath$dir:"
2721           done
2722           finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
2723         fi
2724       fi
2725
2726       if test "$hardcode_action" = relink; then
2727         # Fast installation is not supported
2728         link_command="$compile_var$compile_command$compile_rpath"
2729         relink_command="$finalize_var$finalize_command$finalize_rpath"
2730
2731         $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
2732         $echo "$modename: \`$output' will be relinked during installation" 1>&2
2733       else
2734         if test "$fast_install" != no; then
2735           link_command="$finalize_var$compile_command$finalize_rpath"
2736           if test "$fast_install" = yes; then
2737             relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
2738           else
2739             # fast_install is set to needless
2740             relink_command=
2741           fi
2742         else
2743           link_command="$compile_var$compile_command$compile_rpath"
2744           relink_command="$finalize_var$finalize_command$finalize_rpath"
2745         fi
2746       fi
2747
2748       # Replace the output file specification.
2749       link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
2750
2751       # Delete the old output files.
2752       $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
2753
2754       $show "$link_command"
2755       $run eval "$link_command" || exit $?
2756
2757       # Now create the wrapper script.
2758       $show "creating $output"
2759
2760       # Quote the relink command for shipping.
2761       if test -n "$relink_command"; then
2762         relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
2763       fi
2764
2765       # Quote $echo for shipping.
2766       if test "X$echo" = "X$SHELL $0 --fallback-echo"; then
2767         case "$0" in
2768         [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $0 --fallback-echo";;
2769         *) qecho="$SHELL `pwd`/$0 --fallback-echo";;
2770         esac
2771         qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
2772       else
2773         qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
2774       fi
2775
2776       # Only actually do things if our run command is non-null.
2777       if test -z "$run"; then
2778         # win32 will think the script is a binary if it has
2779         # a .exe suffix, so we strip it off here.
2780         case $output in
2781           *.exe) output=`echo $output|sed 's,.exe$,,'` ;;
2782         esac
2783         $rm $output
2784         trap "$rm $output; exit 1" 1 2 15
2785
2786         # quick and dirty hack by Elrond <Elrond@Wunder-Nett.org>
2787         # to get libtool work with paths in its
2788         # output names.
2789         relink_curdir="`pwd`"
2790
2791         $echo > $output "\
2792 #! $SHELL
2793
2794 # $output - temporary wrapper script for $objdir/$outputname
2795 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
2796 #
2797 # The $output program cannot be directly executed until all the libtool
2798 # libraries that it depends on are installed.
2799 #
2800 # This wrapper script should never be moved out of the build directory.
2801 # If it is, it will not operate correctly.
2802
2803 # Sed substitution that helps us do robust quoting.  It backslashifies
2804 # metacharacters that are still active within double-quoted strings.
2805 Xsed='sed -e 1s/^X//'
2806 sed_quote_subst='$sed_quote_subst'
2807
2808 # The HP-UX ksh and POSIX shell print the target directory to stdout
2809 # if CDPATH is set.
2810 if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi
2811
2812 relink_curdir=\"$relink_curdir\"
2813 relink_command=\"$relink_command\"
2814
2815 # This environment variable determines our operation mode.
2816 if test \"\$libtool_install_magic\" = \"$magic\"; then
2817   # install mode needs the following variable:
2818   link_against_libtool_libs='$link_against_libtool_libs'
2819 else
2820   # When we are sourced in execute mode, \$file and \$echo are already set.
2821   if test \"\$libtool_execute_magic\" != \"$magic\"; then
2822     echo=\"$qecho\"
2823     file=\"\$0\"
2824     # Make sure echo works.
2825     if test \"X\$1\" = X--no-reexec; then
2826       # Discard the --no-reexec flag, and continue.
2827       shift
2828     elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
2829       # Yippee, \$echo works!
2830       :
2831     else
2832       # Restart under the correct shell, and then maybe \$echo will work.
2833       exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
2834     fi
2835   fi\
2836 "
2837         $echo >> $output "\
2838
2839   # Find the directory that this script lives in.
2840   thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
2841   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
2842
2843   # Follow symbolic links until we get to the real thisdir.
2844   file=\`ls -ld \"\$file\" | sed -n 's/.*-> //p'\`
2845   while test -n \"\$file\"; do
2846     destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
2847
2848     # If there was a directory component, then change thisdir.
2849     if test \"x\$destdir\" != \"x\$file\"; then
2850       case \"\$destdir\" in
2851       [\\/]* | [A-Za-z]:[\\/]*) thisdir=\"\$destdir\" ;;
2852       *) thisdir=\"\$thisdir/\$destdir\" ;;
2853       esac
2854     fi
2855
2856     file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
2857     file=\`ls -ld \"\$thisdir/\$file\" | sed -n 's/.*-> //p'\`
2858   done
2859
2860   # Try to get the absolute directory name.
2861   absdir=\`cd \"\$thisdir\" && pwd\`
2862   test -n \"\$absdir\" && thisdir=\"\$absdir\"
2863 "
2864
2865         if test "$fast_install" = yes; then
2866           echo >> $output "\
2867   program=lt-'$outputname'
2868   progdir=\"\$thisdir/$objdir\"
2869
2870   if test ! -f \"\$progdir/\$program\" || \\
2871      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | sed 1q\`; \\
2872        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
2873
2874     file=\"\$\$-\$program\"
2875
2876     if test ! -d \"\$progdir\"; then
2877       $mkdir \"\$progdir\"
2878     else
2879       $rm \"\$progdir/\$file\"
2880     fi"
2881
2882           echo >> $output "\
2883
2884     # relink executable if necessary
2885     if test -n \"\$relink_command\"; then
2886       if (cd \"\$relink_curdir\" && eval \$relink_command); then :
2887       else
2888         $rm \"\$progdir/\$file\"
2889         exit 1
2890       fi
2891     fi
2892
2893     $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
2894     { $rm \"\$progdir/\$program\";
2895       $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
2896     $rm \"\$progdir/\$file\"
2897   fi"
2898         else
2899           echo >> $output "\
2900   program='$outputname'
2901   progdir=\"\$thisdir/$objdir\"
2902 "
2903         fi
2904
2905         echo >> $output "\
2906
2907   if test -f \"\$progdir/\$program\"; then"
2908
2909         # Export our shlibpath_var if we have one.
2910         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
2911           $echo >> $output "\
2912     # Add our own library path to $shlibpath_var
2913     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
2914
2915     # Some systems cannot cope with colon-terminated $shlibpath_var
2916     # The second colon is a workaround for a bug in BeOS R4 sed
2917     $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
2918
2919     export $shlibpath_var
2920 "
2921         fi
2922
2923         # fixup the dll searchpath if we need to.
2924         if test -n "$dllsearchpath"; then
2925           $echo >> $output "\
2926     # Add the dll search path components to the executable PATH
2927     PATH=$dllsearchpath:\$PATH
2928 "
2929         fi
2930
2931         $echo >> $output "\
2932     if test \"\$libtool_execute_magic\" != \"$magic\"; then
2933       # Run the actual program with our arguments.
2934 "
2935         case $host in
2936         *-*-cygwin* | *-*-mingw | *-*-os2*)
2937           # win32 systems need to use the prog path for dll
2938           # lookup to work
2939           $echo >> $output "\
2940       exec \$progdir\\\\\$program \${1+\"\$@\"}
2941 "
2942           ;;
2943         *)
2944           $echo >> $output "\
2945       # Export the path to the program.
2946       PATH=\"\$progdir:\$PATH\"
2947       export PATH
2948
2949       exec \$program \${1+\"\$@\"}
2950 "
2951           ;;
2952         esac
2953         $echo >> $output "\
2954       \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
2955       exit 1
2956     fi
2957   else
2958     # The program doesn't exist.
2959     \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
2960     \$echo \"This script is just a wrapper for \$program.\" 1>&2
2961     echo \"See the $PACKAGE documentation for more information.\" 1>&2
2962     exit 1
2963   fi
2964 fi\
2965 "
2966         chmod +x $output
2967       fi
2968       exit 0
2969       ;;
2970     esac
2971
2972     # See if we need to build an old-fashioned archive.
2973     for oldlib in $oldlibs; do
2974
2975       if test "$build_libtool_libs" = convenience; then
2976         oldobjs="$libobjs_save"
2977         addlibs="$convenience"
2978         build_libtool_libs=no
2979       else
2980         if test "$build_libtool_libs" = module; then
2981           oldobjs="$libobjs_save"
2982           build_libtool_libs=no
2983         else
2984           oldobjs="$objs "`$echo "X$libobjs_save" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`
2985         fi
2986         addlibs="$old_convenience"
2987       fi
2988
2989       if test -n "$addlibs"; then
2990         gentop="$output_objdir/${outputname}x"
2991         $show "${rm}r $gentop"
2992         $run ${rm}r "$gentop"
2993         $show "mkdir $gentop"
2994         $run mkdir "$gentop"
2995         status=$?
2996         if test $status -ne 0 && test ! -d "$gentop"; then
2997           exit $status
2998         fi
2999         generated="$generated $gentop"
3000
3001         # Add in members from convenience archives.
3002         for xlib in $addlibs; 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           oldobjs="$oldobjs "`find $xdir -name \*.${objext} -print -o -name \*.lo -print | $NL2SP`
3023         done
3024       fi
3025
3026       # Do each command in the archive commands.
3027       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
3028         eval cmds=\"$old_archive_from_new_cmds\"
3029       else
3030         # Ensure that we have .o objects in place in case we decided
3031         # not to build a shared library, and have fallen back to building
3032         # static libs even though --disable-static was passed!
3033         for oldobj in $oldobjs; do
3034           if test ! -f $oldobj; then
3035             xdir=`$echo "X$oldobj" | $Xsed -e 's%/[^/]*$%%'`
3036             if test "X$xdir" = "X$oldobj"; then
3037               xdir="."
3038             else
3039               xdir="$xdir"
3040             fi
3041             baseobj=`$echo "X$oldobj" | $Xsed -e 's%^.*/%%'`
3042             obj=`$echo "X$baseobj" | $Xsed -e "$o2lo"`
3043             $show "(cd $xdir && ${LN_S} $obj $baseobj)"
3044             $run eval '(cd $xdir && ${LN_S} $obj $baseobj)' || exit $?
3045           fi
3046         done
3047
3048         eval cmds=\"$old_archive_cmds\"
3049       fi
3050       IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
3051       for cmd in $cmds; do
3052         IFS="$save_ifs"
3053         $show "$cmd"
3054         $run eval "$cmd" || exit $?
3055       done
3056       IFS="$save_ifs"
3057     done
3058
3059     if test -n "$generated"; then
3060       $show "${rm}r$generated"
3061       $run ${rm}r$generated
3062     fi
3063
3064     # Now create the libtool archive.
3065     case "$output" in
3066     *.la)
3067       old_library=
3068       test "$build_old_libs" = yes && old_library="$libname.$libext"
3069       $show "creating $output"
3070
3071       if test -n "$xrpath"; then
3072         temp_xrpath=
3073         for libdir in $xrpath; do
3074           temp_xrpath="$temp_xrpath -R$libdir"
3075         done
3076         dependency_libs="$temp_xrpath $dependency_libs"
3077       fi
3078
3079       # Only create the output if not a dry run.
3080       if test -z "$run"; then
3081         for installed in no yes; do
3082           if test "$installed" = yes; then
3083             if test -z "$install_libdir"; then
3084               break
3085             fi
3086             output="$output_objdir/$outputname"i
3087           fi
3088           $rm $output
3089           $echo > $output "\
3090 # $outputname - a libtool library file
3091 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
3092 #
3093 # Please DO NOT delete this file!
3094 # It is necessary for linking the library.
3095
3096 # The name that we can dlopen(3).
3097 dlname='$dlname'
3098
3099 # Names of this library.
3100 library_names='$library_names'
3101
3102 # The name of the static archive.
3103 old_library='$old_library'
3104
3105 # Libraries that this one depends upon.
3106 dependency_libs='$dependency_libs'
3107
3108 # Version information for $libname.
3109 current=$current
3110 age=$age
3111 revision=$revision
3112
3113 # Is this an already installed library?
3114 installed=$installed
3115
3116 # Directory that this library needs to be installed in:
3117 libdir='$install_libdir'\
3118 "
3119         done
3120       fi
3121
3122       # Do a symbolic link so that the libtool archive can be found in
3123       # LD_LIBRARY_PATH before the program is installed.
3124       $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
3125       $run eval "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)" || exit $?
3126       ;;
3127     esac
3128     exit 0
3129     ;;
3130
3131   # libtool install mode
3132   install)
3133     modename="$modename: install"
3134
3135     # There may be an optional sh(1) argument at the beginning of
3136     # install_prog (especially on Windows NT).
3137     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh; then
3138       # Aesthetically quote it.
3139       arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
3140       case "$arg" in
3141       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
3142         arg="\"$arg\""
3143         ;;
3144       esac
3145       install_prog="$arg "
3146       arg="$1"
3147       shift
3148     else
3149       install_prog=
3150       arg="$nonopt"
3151     fi
3152
3153     # The real first argument should be the name of the installation program.
3154     # Aesthetically quote it.
3155     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
3156     case "$arg" in
3157     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*)
3158       arg="\"$arg\""
3159       ;;
3160     esac
3161     install_prog="$install_prog$arg"
3162
3163     # We need to accept at least all the BSD install flags.
3164     dest=
3165     files=
3166     opts=
3167     prev=
3168     install_type=
3169     isdir=no
3170     stripme=
3171     for arg
3172     do
3173       if test -n "$dest"; then
3174         files="$files $dest"
3175         dest="$arg"
3176         continue
3177       fi
3178
3179       case "$arg" in
3180       -d) isdir=yes ;;
3181       -f) prev="-f" ;;
3182       -g) prev="-g" ;;
3183       -m) prev="-m" ;;
3184       -o) prev="-o" ;;
3185       -s)
3186         stripme=" -s"
3187         continue
3188         ;;
3189       -*) ;;
3190
3191       *)
3192         # If the previous option needed an argument, then skip it.
3193         if test -n "$prev"; then
3194           prev=
3195         else
3196           dest="$arg"
3197           continue
3198         fi
3199         ;;
3200       esac
3201
3202       # Aesthetically quote the argument.
3203       arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
3204       case "$arg" in
3205       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
3206         arg="\"$arg\""
3207         ;;
3208       esac
3209       install_prog="$install_prog $arg"
3210     done
3211
3212     if test -z "$install_prog"; then
3213       $echo "$modename: you must specify an install program" 1>&2
3214       $echo "$help" 1>&2
3215       exit 1
3216     fi
3217
3218     if test -n "$prev"; then
3219       $echo "$modename: the \`$prev' option requires an argument" 1>&2
3220       $echo "$help" 1>&2
3221       exit 1
3222     fi
3223
3224     if test -z "$files"; then
3225       if test -z "$dest"; then
3226         $echo "$modename: no file or destination specified" 1>&2
3227       else
3228         $echo "$modename: you must specify a destination" 1>&2
3229       fi
3230       $echo "$help" 1>&2
3231       exit 1
3232     fi
3233
3234     # Strip any trailing slash from the destination.
3235     dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
3236
3237     # Check to see that the destination is a directory.
3238     test -d "$dest" && isdir=yes
3239     if test "$isdir" = yes; then
3240       destdir="$dest"
3241       destname=
3242     else
3243       destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
3244       test "X$destdir" = "X$dest" && destdir=.
3245       destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
3246
3247       # Not a directory, so check to see that there is only one file specified.
3248       set dummy $files
3249       if test $# -gt 2; then
3250         $echo "$modename: \`$dest' is not a directory" 1>&2
3251         $echo "$help" 1>&2
3252         exit 1
3253       fi
3254     fi
3255     case "$destdir" in
3256     [\\/]* | [A-Za-z]:[\\/]*) ;;
3257     *)
3258       for file in $files; do
3259         case "$file" in
3260         *.lo) ;;
3261         *)
3262           $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
3263           $echo "$help" 1>&2
3264           exit 1
3265           ;;
3266         esac
3267       done
3268       ;;
3269     esac
3270
3271     # This variable tells wrapper scripts just to set variables rather
3272     # than running their programs.
3273     libtool_install_magic="$magic"
3274
3275     staticlibs=
3276     future_libdirs=
3277     current_libdirs=
3278     for file in $files; do
3279
3280       # Do each installation.
3281       case "$file" in
3282       *.a | *.lib)
3283         # Do the static libraries later.
3284         staticlibs="$staticlibs $file"
3285         ;;
3286
3287       *.la)
3288         # Check to see that this really is a libtool archive.
3289         if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
3290         else
3291           $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
3292           $echo "$help" 1>&2
3293           exit 1
3294         fi
3295
3296         library_names=
3297         old_library=
3298         # If there is no directory component, then add one.
3299         case "$file" in
3300         */* | *\\*) . $file ;;
3301         *) . ./$file ;;
3302         esac
3303
3304         # Add the libdir to current_libdirs if it is the destination.
3305         if test "X$destdir" = "X$libdir"; then
3306           case "$current_libdirs " in
3307           *" $libdir "*) ;;
3308           *) current_libdirs="$current_libdirs $libdir" ;;
3309           esac
3310         else
3311           # Note the libdir as a future libdir.
3312           case "$future_libdirs " in
3313           *" $libdir "*) ;;
3314           *) future_libdirs="$future_libdirs $libdir" ;;
3315           esac
3316         fi
3317
3318         dir="`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/"
3319         test "X$dir" = "X$file/" && dir=
3320         dir="$dir$objdir"
3321
3322         # See the names of the shared library.
3323         set dummy $library_names
3324         if test -n "$2"; then
3325           realname="$2"
3326           shift
3327           shift
3328
3329           # Install the shared library and build the symlinks.
3330           $show "$install_prog $dir/$realname $destdir/$realname"
3331           $run eval "$install_prog $dir/$realname $destdir/$realname" || exit $?
3332
3333           if test $# -gt 0; then
3334             # Delete the old symlinks, and create new ones.
3335             for linkname
3336             do
3337               if test "$linkname" != "$realname"; then
3338                 $show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
3339                 $run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
3340               fi
3341             done
3342           fi
3343
3344           # Do each command in the postinstall commands.
3345           lib="$destdir/$realname"
3346           eval cmds=\"$postinstall_cmds\"
3347           IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
3348           for cmd in $cmds; do
3349             IFS="$save_ifs"
3350             $show "$cmd"
3351             $run eval "$cmd" || exit $?
3352           done
3353           IFS="$save_ifs"
3354         fi
3355
3356         # Install the pseudo-library for information purposes.
3357         name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
3358         instname="$dir/$name"i
3359         $show "$install_prog $instname $destdir/$name"
3360         $run eval "$install_prog $instname $destdir/$name" || exit $?
3361
3362         # Maybe install the static library, too.
3363         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
3364         ;;
3365
3366       *.lo)
3367         # Install (i.e. copy) a libtool object.
3368
3369         # Figure out destination file name, if it wasn't already specified.
3370         if test -n "$destname"; then
3371           destfile="$destdir/$destname"
3372         else
3373           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
3374           destfile="$destdir/$destfile"
3375         fi
3376
3377         # Deduce the name of the destination old-style object file.
3378         case "$destfile" in
3379         *.lo)
3380           staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
3381           ;;
3382         *.o | *.obj)
3383           staticdest="$destfile"
3384           destfile=
3385           ;;
3386         *)
3387           $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
3388           $echo "$help" 1>&2
3389           exit 1
3390           ;;
3391         esac
3392
3393         # Install the libtool object if requested.
3394         if test -n "$destfile"; then
3395           $show "$install_prog $file $destfile"
3396           $run eval "$install_prog $file $destfile" || exit $?
3397         fi
3398
3399         # Install the old object if enabled.
3400         if test "$build_old_libs" = yes; then
3401           # Deduce the name of the old-style object file.
3402           staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
3403
3404           $show "$install_prog $staticobj $staticdest"
3405           $run eval "$install_prog \$staticobj \$staticdest" || exit $?
3406         fi
3407         exit 0
3408         ;;
3409
3410       *)
3411         # Figure out destination file name, if it wasn't already specified.
3412         if test -n "$destname"; then
3413           destfile="$destdir/$destname"
3414         else
3415           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
3416           destfile="$destdir/$destfile"
3417         fi
3418
3419         # Do a test to see if this is really a libtool program.
3420         if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
3421           link_against_libtool_libs=
3422           relink_command=
3423
3424           # If there is no directory component, then add one.
3425           case "$file" in
3426           */* | *\\*) . $file ;;
3427           *) . ./$file ;;
3428           esac
3429
3430           # Check the variables that should have been set.
3431           if test -z "$link_against_libtool_libs"; then
3432             $echo "$modename: invalid libtool wrapper script \`$file'" 1>&2
3433             exit 1
3434           fi
3435
3436           finalize=yes
3437           for lib in $link_against_libtool_libs; do
3438             # Check to see that each library is installed.
3439             libdir=
3440             if test -f "$lib"; then
3441               # If there is no directory component, then add one.
3442               case "$lib" in
3443               */* | *\\*) . $lib ;;
3444               *) . ./$lib ;;
3445               esac
3446             fi
3447             libfile="$libdir/`$echo "X$lib" | $Xsed -e 's%^.*/%%g'`"
3448             if test -n "$libdir" && test ! -f "$libfile"; then
3449               $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
3450               finalize=no
3451             fi
3452           done
3453
3454           outputname=
3455           if test "$fast_install" = no && test -n "$relink_command"; then
3456             if test "$finalize" = yes && test -z "$run"; then
3457               tmpdir="/tmp"
3458               test -n "$TMPDIR" && tmpdir="$TMPDIR"
3459               tmpdir="$tmpdir/libtool-$$"
3460               if $mkdir -p "$tmpdir" && chmod 700 "$tmpdir"; then :
3461               else
3462                 $echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
3463                 continue
3464               fi
3465               # quick and dirty hack by Elrond <Elrond@Wunder-Nett.org>
3466               # to get libtool work with paths in its
3467               # output names.
3468               file=`$echo "X$file" | $Xsed -e 's%/%_%g'`
3469               outputname="$tmpdir/$file"
3470               # Replace the output file specification.
3471               relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
3472
3473               $show "$relink_command"
3474               if $run eval "$relink_command"; then :
3475               else
3476                 $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
3477                 ${rm}r "$tmpdir"
3478                 continue
3479               fi
3480               file="$outputname"
3481             else
3482               $echo "$modename: warning: cannot relink \`$file'" 1>&2
3483             fi
3484           else
3485             # Install the binary that we compiled earlier.
3486             file=`$echo "X$file" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
3487           fi
3488         fi
3489
3490         $show "$install_prog$stripme $file $destfile"
3491         $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
3492         test -n "$outputname" && ${rm}r "$tmpdir"
3493         ;;
3494       esac
3495     done
3496
3497     for file in $staticlibs; do
3498       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
3499
3500       # Set up the ranlib parameters.
3501       oldlib="$destdir/$name"
3502
3503       $show "$install_prog $file $oldlib"
3504       $run eval "$install_prog \$file \$oldlib" || exit $?
3505
3506       # Do each command in the postinstall commands.
3507       eval cmds=\"$old_postinstall_cmds\"
3508       IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
3509       for cmd in $cmds; do
3510         IFS="$save_ifs"
3511         $show "$cmd"
3512         $run eval "$cmd" || exit $?
3513       done
3514       IFS="$save_ifs"
3515     done
3516
3517     if test -n "$future_libdirs"; then
3518       $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
3519     fi
3520
3521     if test -n "$current_libdirs"; then
3522       # Maybe just do a dry run.
3523       test -n "$run" && current_libdirs=" -n$current_libdirs"
3524       exec $SHELL $0 --finish$current_libdirs
3525       exit 1
3526     fi
3527
3528     exit 0
3529     ;;
3530
3531   # libtool finish mode
3532   finish)
3533     modename="$modename: finish"
3534     libdirs="$nonopt"
3535     admincmds=
3536
3537     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
3538       for dir
3539       do
3540         libdirs="$libdirs $dir"
3541       done
3542
3543       for libdir in $libdirs; do
3544         if test -n "$finish_cmds"; then
3545           # Do each command in the finish commands.
3546           eval cmds=\"$finish_cmds\"
3547           IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
3548           for cmd in $cmds; do
3549             IFS="$save_ifs"
3550             $show "$cmd"
3551             $run eval "$cmd" || admincmds="$admincmds
3552        $cmd"
3553           done
3554           IFS="$save_ifs"
3555         fi
3556         if test -n "$finish_eval"; then
3557           # Do the single finish_eval.
3558           eval cmds=\"$finish_eval\"
3559           $run eval "$cmds" || admincmds="$admincmds
3560        $cmds"
3561         fi
3562       done
3563     fi
3564
3565     # Exit here if they wanted silent mode.
3566     test "$show" = : && exit 0
3567
3568     echo "----------------------------------------------------------------------"
3569     echo "Libraries have been installed in:"
3570     for libdir in $libdirs; do
3571       echo "   $libdir"
3572     done
3573     echo
3574     echo "If you ever happen to want to link against installed libraries"
3575     echo "in a given directory, LIBDIR, you must either use libtool, and"
3576     echo "specify the full pathname of the library, or use \`-LLIBDIR'"
3577     echo "flag during linking and do at least one of the following:"
3578     if test -n "$shlibpath_var"; then
3579       echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
3580       echo "     during execution"
3581     fi
3582     if test -n "$runpath_var"; then
3583       echo "   - add LIBDIR to the \`$runpath_var' environment variable"
3584       echo "     during linking"
3585     fi
3586     if test -n "$hardcode_libdir_flag_spec"; then
3587       libdir=LIBDIR
3588       eval flag=\"$hardcode_libdir_flag_spec\"
3589
3590       echo "   - use the \`$flag' linker flag"
3591     fi
3592     if test -n "$admincmds"; then
3593       echo "   - have your system administrator run these commands:$admincmds"
3594     fi
3595     if test -f /etc/ld.so.conf; then
3596       echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
3597     fi
3598     echo
3599     echo "See any operating system documentation about shared libraries for"
3600     echo "more information, such as the ld(1) and ld.so(8) manual pages."
3601     echo "----------------------------------------------------------------------"
3602     exit 0
3603     ;;
3604
3605   # libtool execute mode
3606   execute)
3607     modename="$modename: execute"
3608
3609     # The first argument is the command name.
3610     cmd="$nonopt"
3611     if test -z "$cmd"; then
3612       $echo "$modename: you must specify a COMMAND" 1>&2
3613       $echo "$help"
3614       exit 1
3615     fi
3616
3617     # Handle -dlopen flags immediately.
3618     for file in $execute_dlfiles; do
3619       if test ! -f "$file"; then
3620         $echo "$modename: \`$file' is not a file" 1>&2
3621         $echo "$help" 1>&2
3622         exit 1
3623       fi
3624
3625       dir=
3626       case "$file" in
3627       *.la)
3628         # Check to see that this really is a libtool archive.
3629         if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
3630         else
3631           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
3632           $echo "$help" 1>&2
3633           exit 1
3634         fi
3635
3636         # Read the libtool library.
3637         dlname=
3638         library_names=
3639
3640         # If there is no directory component, then add one.
3641         case "$file" in
3642         */* | *\\*) . $file ;;
3643         *) . ./$file ;;
3644         esac
3645
3646         # Skip this library if it cannot be dlopened.
3647         if test -z "$dlname"; then
3648           # Warn if it was a shared library.
3649           test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
3650           continue
3651         fi
3652
3653         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
3654         test "X$dir" = "X$file" && dir=.
3655
3656         if test -f "$dir/$objdir/$dlname"; then
3657           dir="$dir/$objdir"
3658         else
3659           $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
3660           exit 1
3661         fi
3662         ;;
3663
3664       *.lo)
3665         # Just add the directory containing the .lo file.
3666         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
3667         test "X$dir" = "X$file" && dir=.
3668         ;;
3669
3670       *)
3671         $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
3672         continue
3673         ;;
3674       esac
3675
3676       # Get the absolute pathname.
3677       absdir=`cd "$dir" && pwd`
3678       test -n "$absdir" && dir="$absdir"
3679
3680       # Now add the directory to shlibpath_var.
3681       if eval "test -z \"\$$shlibpath_var\""; then
3682         eval "$shlibpath_var=\"\$dir\""
3683       else
3684         eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
3685       fi
3686     done
3687
3688     # This variable tells wrapper scripts just to set shlibpath_var
3689     # rather than running their programs.
3690     libtool_execute_magic="$magic"
3691
3692     # Check if any of the arguments is a wrapper script.
3693     args=
3694     for file
3695     do
3696       case "$file" in
3697       -*) ;;
3698       *)
3699         # Do a test to see if this is really a libtool program.
3700         if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
3701           # If there is no directory component, then add one.
3702           case "$file" in
3703           */* | *\\*) . $file ;;
3704           *) . ./$file ;;
3705           esac
3706
3707           # Transform arg to wrapped name.
3708           file="$progdir/$program"
3709         fi
3710         ;;
3711       esac
3712       # Quote arguments (to preserve shell metacharacters).
3713       file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
3714       args="$args \"$file\""
3715     done
3716
3717     if test -z "$run"; then
3718       if test -n "$shlibpath_var"; then
3719         # Export the shlibpath_var.
3720         eval "export $shlibpath_var"
3721       fi
3722
3723       # Restore saved enviroment variables
3724       if test "${save_LC_ALL+set}" = set; then
3725         LC_ALL="$save_LC_ALL"; export LC_ALL
3726       fi
3727       if test "${save_LANG+set}" = set; then
3728         LANG="$save_LANG"; export LANG
3729       fi
3730
3731       # Now actually exec the command.
3732       eval "exec \$cmd$args"
3733
3734       $echo "$modename: cannot exec \$cmd$args"
3735       exit 1
3736     else
3737       # Display what would be done.
3738       if test -n "$shlibpath_var"; then
3739         eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
3740         $echo "export $shlibpath_var"
3741       fi
3742       $echo "$cmd$args"
3743       exit 0
3744     fi
3745     ;;
3746
3747   # libtool uninstall mode
3748   uninstall)
3749     modename="$modename: uninstall"
3750     rm="$nonopt"
3751     files=
3752
3753     for arg
3754     do
3755       case "$arg" in
3756       -*) rm="$rm $arg" ;;
3757       *) files="$files $arg" ;;
3758       esac
3759     done
3760
3761     if test -z "$rm"; then
3762       $echo "$modename: you must specify an RM program" 1>&2
3763       $echo "$help" 1>&2
3764       exit 1
3765     fi
3766
3767     for file in $files; do
3768       dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
3769       test "X$dir" = "X$file" && dir=.
3770       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
3771
3772       rmfiles="$file"
3773
3774       case "$name" in
3775       *.la)
3776         # Possibly a libtool archive, so verify it.
3777         if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
3778           . $dir/$name
3779
3780           # Delete the libtool libraries and symlinks.
3781           for n in $library_names; do
3782             rmfiles="$rmfiles $dir/$n"
3783           done
3784           test -n "$old_library" && rmfiles="$rmfiles $dir/$old_library"
3785
3786           $show "$rm $rmfiles"
3787           $run $rm $rmfiles
3788
3789           if test -n "$library_names"; then
3790             # Do each command in the postuninstall commands.
3791             eval cmds=\"$postuninstall_cmds\"
3792             IFS="${IFS=         }"; save_ifs="$IFS"; IFS='~'
3793             for cmd in $cmds; do
3794               IFS="$save_ifs"
3795               $show "$cmd"
3796               $run eval "$cmd"
3797             done
3798             IFS="$save_ifs"
3799           fi
3800
3801           if test -n "$old_library"; then
3802             # Do each command in the old_postuninstall commands.
3803             eval cmds=\"$old_postuninstall_cmds\"
3804             IFS="${IFS=         }"; save_ifs="$IFS"; IFS='~'
3805             for cmd in $cmds; do
3806               IFS="$save_ifs"
3807               $show "$cmd"
3808               $run eval "$cmd"
3809             done
3810             IFS="$save_ifs"
3811           fi
3812
3813           # FIXME: should reinstall the best remaining shared library.
3814         fi
3815         ;;
3816
3817       *.lo)
3818         if test "$build_old_libs" = yes; then
3819           oldobj=`$echo "X$name" | $Xsed -e "$lo2o"`
3820           rmfiles="$rmfiles $dir/$oldobj"
3821         fi
3822         $show "$rm $rmfiles"
3823         $run $rm $rmfiles
3824         ;;
3825
3826       *)
3827         $show "$rm $rmfiles"
3828         $run $rm $rmfiles
3829         ;;
3830       esac
3831     done
3832     exit 0
3833     ;;
3834
3835   "")
3836     $echo "$modename: you must specify a MODE" 1>&2
3837     $echo "$generic_help" 1>&2
3838     exit 1
3839     ;;
3840   esac
3841
3842   $echo "$modename: invalid operation mode \`$mode'" 1>&2
3843   $echo "$generic_help" 1>&2
3844   exit 1
3845 fi # test -z "$show_help"
3846
3847 # We need to display help for each of the modes.
3848 case "$mode" in
3849 "") $echo \
3850 "Usage: $modename [OPTION]... [MODE-ARG]...
3851
3852 Provide generalized library-building support services.
3853
3854     --config          show all configuration variables
3855     --debug           enable verbose shell tracing
3856 -n, --dry-run         display commands without modifying any files
3857     --features        display basic configuration information and exit
3858     --finish          same as \`--mode=finish'
3859     --help            display this help message and exit
3860     --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
3861     --quiet           same as \`--silent'
3862     --silent          don't print informational messages
3863     --version         print version information
3864
3865 MODE must be one of the following:
3866
3867       compile         compile a source file into a libtool object
3868       execute         automatically set library path, then run a program
3869       finish          complete the installation of libtool libraries
3870       install         install libraries or executables
3871       link            create a library or an executable
3872       uninstall       remove libraries from an installed directory
3873
3874 MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
3875 a more detailed description of MODE."
3876   exit 0
3877   ;;
3878
3879 compile)
3880   $echo \
3881 "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
3882
3883 Compile a source file into a libtool library object.
3884
3885 This mode accepts the following additional options:
3886
3887   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
3888   -static           always build a \`.o' file suitable for static linking
3889
3890 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
3891 from the given SOURCEFILE.
3892
3893 The output file name is determined by removing the directory component from
3894 SOURCEFILE, then substituting the C source code suffix \`.c' with the
3895 library object suffix, \`.lo'."
3896   ;;
3897
3898 execute)
3899   $echo \
3900 "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
3901
3902 Automatically set library path, then run a program.
3903
3904 This mode accepts the following additional options:
3905
3906   -dlopen FILE      add the directory containing FILE to the library path
3907
3908 This mode sets the library path environment variable according to \`-dlopen'
3909 flags.
3910
3911 If any of the ARGS are libtool executable wrappers, then they are translated
3912 into their corresponding uninstalled binary, and any of their required library
3913 directories are added to the library path.
3914
3915 Then, COMMAND is executed, with ARGS as arguments."
3916   ;;
3917
3918 finish)
3919   $echo \
3920 "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
3921
3922 Complete the installation of libtool libraries.
3923
3924 Each LIBDIR is a directory that contains libtool libraries.
3925
3926 The commands that this mode executes may require superuser privileges.  Use
3927 the \`--dry-run' option if you just want to see what would be executed."
3928   ;;
3929
3930 install)
3931   $echo \
3932 "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
3933
3934 Install executables or libraries.
3935
3936 INSTALL-COMMAND is the installation command.  The first component should be
3937 either the \`install' or \`cp' program.
3938
3939 The rest of the components are interpreted as arguments to that command (only
3940 BSD-compatible install options are recognized)."
3941   ;;
3942
3943 link)
3944   $echo \
3945 "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
3946
3947 Link object files or libraries together to form another library, or to
3948 create an executable program.
3949
3950 LINK-COMMAND is a command using the C compiler that you would use to create
3951 a program from several object files.
3952
3953 The following components of LINK-COMMAND are treated specially:
3954
3955   -all-static       do not do any dynamic linking at all
3956   -avoid-version    do not add a version suffix if possible
3957   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
3958   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
3959   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
3960   -export-symbols SYMFILE
3961                     try to export only the symbols listed in SYMFILE
3962   -export-symbols-regex REGEX
3963                     try to export only the symbols matching REGEX
3964   -LLIBDIR          search LIBDIR for required installed libraries
3965   -lNAME            OUTPUT-FILE requires the installed library libNAME
3966   -module           build a library that can dlopened
3967   -no-undefined     declare that a library does not refer to external symbols
3968   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
3969   -release RELEASE  specify package release information
3970   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
3971   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
3972   -static           do not do any dynamic linking of libtool libraries
3973   -version-info CURRENT[:REVISION[:AGE]]
3974                     specify library version info [each variable defaults to 0]
3975
3976 All other options (arguments beginning with \`-') are ignored.
3977
3978 Every other argument is treated as a filename.  Files ending in \`.la' are
3979 treated as uninstalled libtool libraries, other files are standard or library
3980 object files.
3981
3982 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
3983 only library objects (\`.lo' files) may be specified, and \`-rpath' is
3984 required, except when creating a convenience library.
3985
3986 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
3987 using \`ar' and \`ranlib', or on Windows using \`lib'.
3988
3989 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
3990 is created, otherwise an executable program is created."
3991   ;;
3992
3993 uninstall)
3994   $echo \
3995 "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
3996
3997 Remove libraries from an installation directory.
3998
3999 RM is the name of the program to use to delete files associated with each FILE
4000 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
4001 to RM.
4002
4003 If FILE is a libtool library, all the files associated with it are deleted.
4004 Otherwise, only FILE itself is deleted using RM."
4005   ;;
4006
4007 *)
4008   $echo "$modename: invalid operation mode \`$mode'" 1>&2
4009   $echo "$help" 1>&2
4010   exit 1
4011   ;;
4012 esac
4013
4014 echo
4015 $echo "Try \`$modename --help' for more information about other modes."
4016
4017 exit 0
4018
4019 # Local Variables:
4020 # mode:shell-script
4021 # sh-indentation:2
4022 # End: