git.sur5r.net Git - openldap/blob - contrib/ldapc++/ltmain.sh

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