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